Revert "Create API for GrVkMemoryAllocator and impliment use of AMD VulkanMemoryAllocator on this API."

This reverts commit 26c0e4c1f54759249c2d61b50fb5430bd73793f2.

Reason for revert: breaks roll into fuchsia

Original change's description:
> Create API for GrVkMemoryAllocator and impliment use of AMD VulkanMemoryAllocator on this API.
> 
> Bug: skia:
> Change-Id: I1e122e1b11ab308c2f83cb98c36c81511f4507d0
> Reviewed-on: https://skia-review.googlesource.com/129980
> Commit-Queue: Greg Daniel <egdaniel@google.com>
> Reviewed-by: Brian Salomon <bsalomon@google.com>
> Reviewed-by: Jim Van Verth <jvanverth@google.com>

TBR=egdaniel@google.com,jvanverth@google.com,bsalomon@google.com,bungeman@google.com

Change-Id: I6c74978f778987c422e6162e7dd85ea9c6baa0e4
No-Presubmit: true
No-Tree-Checks: true
No-Try: true
Bug: skia:
Reviewed-on: https://skia-review.googlesource.com/130182
Reviewed-by: Greg Daniel <egdaniel@google.com>
Commit-Queue: Greg Daniel <egdaniel@google.com>

5 files changed, 0 insertions, 9442 deletions

diff --git a/third_party/vulkanmemoryallocator/BUILD.gn b/third_party/vulkanmemoryallocator/BUILD.gn
deleted file mode 100644
index cf64e2b57e..0000000000
--- a/third_party/vulkanmemoryallocator/BUILD.gn
+++ /dev/null
@@ -1,26 +0,0 @@
-# Copyright 2018 Google Inc.
-#
-# Use of this source code is governed by a BSD-style license that can be
-# found in the LICENSE file.
-
-import("../third_party.gni")
-
-third_party("vulkanmemoryallocator") {
-  public_include_dirs = [ "./" ]
-  include_dirs = []
-  if (defined(is_skia_standalone) && is_skia_standalone && !is_official_build) {
-    include_dirs += [ "../../tools/gpu/vk" ]
-    include_dirs += [ "../../include/core" ]
-    include_dirs += [ "../../include/config" ]
-  }
-
-  # TODO: As described in the main skia BUILD.gn file we eventually want to move this to be
-  # //third_party/vulkan once clients have created their own //third_party/vulkan directory.
-  deps = [
-    "../vulkan",
-  ]
-  sources = [
-    "GrVulkanMemoryAllocator.cpp",
-    "GrVulkanMemoryAllocator.h",
-  ]
-}
diff --git a/third_party/vulkanmemoryallocator/GrVulkanMemoryAllocator.cpp b/third_party/vulkanmemoryallocator/GrVulkanMemoryAllocator.cpp
deleted file mode 100644
index 58884630c5..0000000000
--- a/third_party/vulkanmemoryallocator/GrVulkanMemoryAllocator.cpp
+++ /dev/null
@@ -1,16 +0,0 @@
-/*
- * Copyright 2018 Google Inc.
- *
- * Use of this source code is governed by a BSD-style license that can be
- * found in the LICENSE file.
- */
-
-// Workaround to make sure we align non-coherent memory to nonCoherentAtomSize.
-#define VMA_DEBUG_ALIGNMENT 256
-
-// We use our own functions pointers
-#define VMA_STATIC_VULKAN_FUNCTIONS 0
-
-#define VMA_IMPLEMENTATION
-#include "GrVulkanMemoryAllocator.h"
-
diff --git a/third_party/vulkanmemoryallocator/GrVulkanMemoryAllocator.h b/third_party/vulkanmemoryallocator/GrVulkanMemoryAllocator.h
deleted file mode 100644
index d1cbebc5e6..0000000000
--- a/third_party/vulkanmemoryallocator/GrVulkanMemoryAllocator.h
+++ /dev/null
@@ -1,18 +0,0 @@
-/*
- * Copyright 2018 Google Inc.
- *
- * Use of this source code is governed by a BSD-style license that can be
- * found in the LICENSE file.
- */
-
-// We use this header to include vk_mem_alloc.h to make sure we always include GrVkDefines.h first.
-// We need to do this so that the corect defines are setup before we include vulkan.h inside of
-// vk_mem_alloc.h
-
-#ifndef GrVulkanMemoryAllocator_DEFINED
-#define GrVulkanMemoryAllocator_DEFINED
-
-#include "../../include/gpu/vk/GrVkDefines.h"
-#include "include/vk_mem_alloc.h"
-
-#endif
diff --git a/third_party/vulkanmemoryallocator/include/LICENSE.txt b/third_party/vulkanmemoryallocator/include/LICENSE.txt
deleted file mode 100644
index dbfe253391..0000000000
--- a/third_party/vulkanmemoryallocator/include/LICENSE.txt
+++ /dev/null
@@ -1,19 +0,0 @@
-Copyright (c) 2017-2018 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.
diff --git a/third_party/vulkanmemoryallocator/include/vk_mem_alloc.h b/third_party/vulkanmemoryallocator/include/vk_mem_alloc.h
deleted file mode 100644
index b621fe7e14..0000000000
--- a/third_party/vulkanmemoryallocator/include/vk_mem_alloc.h
+++ /dev/null
@@ -1,9363 +0,0 @@
-//

-// Copyright (c) 2017-2018 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

-

-#ifdef __cplusplus

-extern "C" {

-#endif

-

-/** \mainpage Vulkan Memory Allocator

-

-<b>Version 2.0.0</b> (2018-03-19)

-

-Copyright (c) 2017-2018 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)

-  - \subpage memory_mapping

-    - [Mapping functions](@ref memory_mapping_mapping_functions)

-    - [Persistently mapped memory](@ref memory_mapping_persistently_mapped_memory)

-    - [Cache control](@ref memory_mapping_cache_control)

-    - [Finding out if memory is mappable](@ref memory_mapping_finding_if_memory_mappable)

-  - \subpage custom_memory_pools

-    - [Choosing memory type index](@ref custom_memory_pools_MemTypeIndex)

-  - \subpage defragmentation

-  - \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 usage_patterns

-  - [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 general_considerations

-  - [Thread safety](@ref general_considerations_thread_safety)

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

-

-\section quick_start_initialization Initialization

-

-At program startup:

-

--# Initialize Vulkan to have `VkPhysicalDevice` and `VkDevice` object.

--# Fill VmaAllocatorCreateInfo structure and create #VmaAllocator object by

-   calling vmaCreateAllocator().

-

-\code

-VmaAllocatorCreateInfo allocatorInfo = {};

-allocatorInfo.physicalDevice = physicalDevice;

-allocatorInfo.device = device;

-

-VmaAllocator allocator;

-vmaCreateAllocator(&allocatorInfo, &allocator);

-\endcode

-

-\section quick_start_resource_allocation Resource allocation

-

-When you want to create a buffer or image:

-

--# Fill `VkBufferCreateInfo` / `VkImageCreateInfo` structure.

--# Fill VmaAllocationCreateInfo structure.

--# Call vmaCreateBuffer() / vmaCreateImage() to get `VkBuffer`/`VkImage` with memory

-   already allocated and bound to it.

-

-\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().

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

--# 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().

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

-

-

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

-They 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;

-VmaBuffer 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

-

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

-- Keeping many large memory blocks mapped may impact performance or stability of some debugging tools.

-

-\section memory_mapping_cache_control Cache control

-  

-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

-using function `vkvkInvalidateMappedMemoryRanges()`

-and flush cache after writing to mapped pointer

-using function `vkFlushMappedMemoryRanges()`.

-Example:

-

-\code

-memcpy(allocInfo.pMappedData, &constantBufferData, sizeof(constantBufferData));

-

-VkMemoryPropertyFlags memFlags;

-vmaGetMemoryTypeProperties(allocator, allocInfo.memoryType, &memFlags);

-if((memFlags & VK_MEMORY_PROPERTY_HOST_COHERENT_BIT) == 0)

-{

-    VkMappedMemoryRange memRange = { VK_STRUCTURE_TYPE_MAPPED_MEMORY_RANGE };

-    memRange.memory = allocInfo.deviceMemory;

-    memRange.offset = allocInfo.offset;

-    memRange.size   = allocInfo.size;

-    vkFlushMappedMemoryRanges(device, 1, &memRange);

-}

-\endcode

-

-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 `VK_MEMORY_PROPERTY_HOST_COHERENT_BIT` flag on all memory types that are

-`VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT`, 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;

-

-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.pUserData != 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 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.

-

-

-\page defragmentation Defragmentation

-

-Interleaved allocations and deallocations of many objects of varying size can

-cause fragmentation, 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 vmaDefragment(). Given set of allocations,

-this function can move them to compact used memory, ensure more continuous free

-space and possibly also free some `VkDeviceMemory`. It can work only on

-allocations made from memory type that is `HOST_VISIBLE`. Allocations are

-modified to point to the new `VkDeviceMemory` and offset. Data in this memory is

-also `memmove`-ed to the new place. However, if you have images or buffers bound

-to these allocations (and you certainly do), you need to destroy, recreate, and

-bind them to the new place in memory.

-

-For further details and example code, see documentation of function

-vmaDefragment().

-

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

-

-

-\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().

-

-

-\page usage_patterns Recommended usage patterns

-

-\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, as it may be very slow.

-

-\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 equally 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 tranfer each time.

--# Create just single copy using #VMA_MEMORY_USAGE_CPU_TO_GPU, map it and fill it on CPU,

-   read it directly on GPU.

--# Create just 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.

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

-

-If you don't want to specialize your code for specific types of GPUs, yon 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.

-

-\section config_Vulkan_functions Pointers to Vulkan functions

-

-The library uses Vulkan functions straight from the `vulkan.h` header by default.

-If you want to provide your own pointers to these functions, e.g. fetched using

-`vkGetInstanceProcAddr()` and `vkGetDeviceProcAddr()`:

-

--# Define `VMA_STATIC_VULKAN_FUNCTIONS 0`.

--# Provide valid pointers through VmaAllocatorCreateInfo::pVulkanFunctions.

-

-\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

-

-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.0-extensions/html/vkspec.html#VK_KHR_dedicated_allocation)

-- [VK_KHR_dedicated_allocation unofficial manual](http://asawicki.info/articles/VK_KHR_dedicated_allocation.php5)

-

-

-

-\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_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 - issuing commands that transfer data between buffers or images, any usage of

-  `VkCommandList` or `VkCommandQueue` and related synchronization is responsibility of the user.

-- Support for any programming languages other than C/C++.

-  Bindings to other languages are welcomed as external projects.

-

-*/

-

-#include <vulkan/vulkan.h>

-

-/** \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      allocator,

-    uint32_t          memoryType,

-    VkDeviceMemory    memory,

-    VkDeviceSize      size);

-/// Callback function called before vkFreeMemory.

-typedef void (VKAPI_PTR *PFN_vmaFreeDeviceMemoryFunction)(

-    VmaAllocator      allocator,

-    uint32_t          memoryType,

-    VkDeviceMemory    memory,

-    VkDeviceSize      size);

-

-/** \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 pfnAllocate;

-    /// Optional, can be null.

-    PFN_vmaFreeDeviceMemoryFunction pfnFree;

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

-

-    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

-    - VK_KHR_dedicated_allocation

-

-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,

-

-    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 vkGetPhysicalDeviceProperties;

-    PFN_vkGetPhysicalDeviceMemoryProperties vkGetPhysicalDeviceMemoryProperties;

-    PFN_vkAllocateMemory vkAllocateMemory;

-    PFN_vkFreeMemory vkFreeMemory;

-    PFN_vkMapMemory vkMapMemory;

-    PFN_vkUnmapMemory vkUnmapMemory;

-    PFN_vkBindBufferMemory vkBindBufferMemory;

-    PFN_vkBindImageMemory vkBindImageMemory;

-    PFN_vkGetBufferMemoryRequirements vkGetBufferMemoryRequirements;

-    PFN_vkGetImageMemoryRequirements vkGetImageMemoryRequirements;

-    PFN_vkCreateBuffer vkCreateBuffer;

-    PFN_vkDestroyBuffer vkDestroyBuffer;

-    PFN_vkCreateImage vkCreateImage;

-    PFN_vkDestroyImage vkDestroyImage;

-    PFN_vkGetBufferMemoryRequirements2KHR vkGetBufferMemoryRequirements2KHR;

-    PFN_vkGetImageMemoryRequirements2KHR vkGetImageMemoryRequirements2KHR;

-} VmaVulkanFunctions;

-

-/// Description of a Allocator to be created.

-typedef struct VmaAllocatorCreateInfo

-{

-    /// Flags for created allocator. Use #VmaAllocatorCreateFlagBits enum.

-    VmaAllocatorCreateFlags flags;

-    /// Vulkan physical device.

-    /** It must be valid throughout whole lifetime of created allocator. */

-    VkPhysicalDevice physicalDevice;

-    /// Vulkan device.

-    /** It must be valid throughout whole lifetime of created allocator. */

-    VkDevice 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* pAllocationCallbacks;

-    /// Informative callbacks for `vkAllocateMemory`, `vkFreeMemory`. Optional.

-    /** Optional, can be null. */

-    const VmaDeviceMemoryCallbacks* 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.

-    */

-    const VkDeviceSize* pHeapSizeLimit;

-    /** \brief Pointers to Vulkan functions. Can be null if you leave define `VMA_STATIC_VULKAN_FUNCTIONS 1`.

-

-    If you leave define `VMA_STATIC_VULKAN_FUNCTIONS 1` in configuration section,

-    you can pass null as this member, because the library will fetch pointers to

-    Vulkan functions internally in a static way, like:

-

-        vulkanFunctions.vkAllocateMemory = &vkAllocateMemory;

-

-    Fill this member if you want to provide your own pointers to Vulkan functions,

-    e.g. fetched using `vkGetInstanceProcAddr()` and `vkGetDeviceProcAddr()`.

-    */

-    const VmaVulkanFunctions* pVulkanFunctions;

-} VmaAllocatorCreateInfo;

-

-/// Creates Allocator object.

-VkResult vmaCreateAllocator(

-    const VmaAllocatorCreateInfo* pCreateInfo,

-    VmaAllocator* pAllocator);

-

-/// Destroys allocator object.

-void vmaDestroyAllocator(

-    VmaAllocator allocator);

-

-/**

-PhysicalDeviceProperties are fetched from physicalDevice by the allocator.

-You can access it here, without fetching it again on your own.

-*/

-void vmaGetPhysicalDeviceProperties(

-    VmaAllocator allocator,

-    const VkPhysicalDeviceProperties** ppPhysicalDeviceProperties);

-

-/**

-PhysicalDeviceMemoryProperties are fetched from physicalDevice by the allocator.

-You can access it here, without fetching it again on your own.

-*/

-void vmaGetMemoryProperties(

-    VmaAllocator allocator,

-    const VkPhysicalDeviceMemoryProperties** 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().

-*/

-void vmaGetMemoryTypeProperties(

-    VmaAllocator allocator,

-    uint32_t memoryTypeIndex,

-    VkMemoryPropertyFlags* 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.

-*/

-void vmaSetCurrentFrameIndex(

-    VmaAllocator 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;

-

-/// Retrieves statistics from current state of the Allocator.

-void vmaCalculateStats(

-    VmaAllocator allocator,

-    VmaStats* pStats);

-

-#define VMA_STATS_STRING_ENABLED 1

-

-#if VMA_STATS_STRING_ENABLED

-

-/// Builds and returns statistics as string in JSON format.

-/** @param[out] ppStatsString Must be freed using vmaFreeStatsString() function.

-*/

-void vmaBuildStatsString(

-    VmaAllocator allocator,

-    char** ppStatsString,

-    VkBool32 detailedMap);

-

-void vmaFreeStatsString(

-    VmaAllocator allocator,

-    char* 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 by device.

-

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

-    Resources created in this pool may still be accessible to the device, but access to them can be slower.

-    Guarantees to be `HOST_VISIBLE` and `HOST_COHERENT`.

-    CPU read may be uncached.

-    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 reads may be uncached and very slow.

-

-    Usage: Resources written frequently by host (dynamic), read by device. E.g. textures, 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,

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

-   

-    This flag must also be used for host visible resources that you want to map

-    simultaneously because otherwise they might end up as regions of the same

-    `VkDeviceMemory`, while mapping same `VkDeviceMemory` multiple times

-    simultaneously is illegal.

-

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

-

-    Is it 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,

-

-    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 prefered. \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 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* 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.

-*/

-VkResult vmaFindMemoryTypeIndex(

-    VmaAllocator allocator,

-    uint32_t memoryTypeBits,

-    const VmaAllocationCreateInfo* pAllocationCreateInfo,

-    uint32_t* 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`

-*/

-VkResult vmaFindMemoryTypeIndexForBufferInfo(

-    VmaAllocator allocator,

-    const VkBufferCreateInfo* pBufferCreateInfo,

-    const VmaAllocationCreateInfo* pAllocationCreateInfo,

-    uint32_t* 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`

-*/

-VkResult vmaFindMemoryTypeIndexForImageInfo(

-    VmaAllocator allocator,

-    const VkImageCreateInfo* pImageCreateInfo,

-    const VmaAllocationCreateInfo* pAllocationCreateInfo,

-    uint32_t* 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 na 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

-    more optimal.

-    */

-    VMA_POOL_CREATE_IGNORE_BUFFER_IMAGE_GRANULARITY_BIT = 0x00000002,

-

-    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. Leave 0 to use default.

-    */

-    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 let the pool be completely empty.

-    */

-    size_t minBlockCount;

-    /** \brief Maximum number of blocks that can be allocated in this pool. Optional.

-

-    Optional. Set to 0 to use `SIZE_MAX`, which means no limit.

-    

-    Set to same value as minBlockCount to have fixed amount of memory allocated

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

-

-    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;

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

-*/

-VkResult vmaCreatePool(

-	VmaAllocator allocator,

-	const VmaPoolCreateInfo* pCreateInfo,

-	VmaPool* pPool);

-

-/** \brief Destroys #VmaPool object and frees Vulkan device memory.

-*/

-void vmaDestroyPool(

-    VmaAllocator allocator,

-    VmaPool pool);

-

-/** \brief Retrieves statistics of existing #VmaPool object.

-

-@param allocator Allocator object.

-@param pool Pool object.

-@param[out] pPoolStats Statistics of specified pool.

-*/

-void vmaGetPoolStats(

-    VmaAllocator allocator,

-    VmaPool pool,

-    VmaPoolStats* 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.

-*/

-void vmaMakePoolAllocationsLost(

-    VmaAllocator allocator,

-    VmaPool pool,

-    size_t* pLostAllocationCount);

-

-/** \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 deviceMemory;

-    /** \brief Offset into deviceMemory object to the beginning of this allocation, in bytes. (deviceMemory, offset) pair is unique to this allocation.

-

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

-    */

-    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 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* 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* 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().

-

-It is recommended to use vmaAllocateMemoryForBuffer(), vmaAllocateMemoryForImage(),

-vmaCreateBuffer(), vmaCreateImage() instead whenever possible.

-*/

-VkResult vmaAllocateMemory(

-    VmaAllocator allocator,

-    const VkMemoryRequirements* pVkMemoryRequirements,

-    const VmaAllocationCreateInfo* pCreateInfo,

-    VmaAllocation* pAllocation,

-    VmaAllocationInfo* 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().

-*/

-VkResult vmaAllocateMemoryForBuffer(

-    VmaAllocator allocator,

-    VkBuffer buffer,

-    const VmaAllocationCreateInfo* pCreateInfo,

-    VmaAllocation* pAllocation,

-    VmaAllocationInfo* pAllocationInfo);

-

-/// Function similar to vmaAllocateMemoryForBuffer().

-VkResult vmaAllocateMemoryForImage(

-    VmaAllocator allocator,

-    VkImage image,

-    const VmaAllocationCreateInfo* pCreateInfo,

-    VmaAllocation* pAllocation,

-    VmaAllocationInfo* pAllocationInfo);

-

-/// Frees memory previously allocated using vmaAllocateMemory(), vmaAllocateMemoryForBuffer(), or vmaAllocateMemoryForImage().

-void vmaFreeMemory(

-    VmaAllocator allocator,

-    VmaAllocation allocation);

-

-/** \brief Returns current information about specified allocation and atomically marks it as used in current frame.

-

-Current paramters 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.

-*/

-void vmaGetAllocationInfo(

-    VmaAllocator allocator,

-    VmaAllocation allocation,

-    VmaAllocationInfo* 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`.

-*/

-VkBool32 vmaTouchAllocation(

-    VmaAllocator allocator,

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

-*/

-void vmaSetAllocationUserData(

-    VmaAllocator allocator,

-    VmaAllocation allocation,

-    void* 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.

-*/

-void vmaCreateLostAllocation(

-    VmaAllocator allocator,

-    VmaAllocation* 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.

-*/

-VkResult vmaMapMemory(

-    VmaAllocator allocator,

-    VmaAllocation allocation,

-    void** ppData);

-

-/** \brief Unmaps memory represented by given allocation, mapped previously using vmaMapMemory().

-

-For details, see description of vmaMapMemory().

-*/

-void vmaUnmapMemory(

-    VmaAllocator allocator,

-    VmaAllocation allocation);

-

-/** \brief Optional configuration parameters to be passed to function vmaDefragment(). */

-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 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, VK_INCOMPLETE if succeeded but didn't make all possible optimizations because limits specified in pDefragmentationInfo have been reached, negative error code in case of error.

-

-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` flag can be compacted. You may pass other

-  allocations but it makes no sense - these will never be moved.

-- You may pass allocations made with #VMA_ALLOCATION_CREATE_DEDICATED_MEMORY_BIT but

-  it makes no sense - they will never be moved.

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

-

-After allocation has been moved, its VmaAllocationInfo::deviceMemory and/or

-VmaAllocationInfo::offset changes. You must query them again using

-vmaGetAllocationInfo() if you need them.

-

-If an allocation has been moved, data in memory is copied to new place

-automatically, but if it was bound to a buffer or an image, you must destroy

-that object yourself, create new one and bind it to the new memory pointed by

-the allocation. You must use `vkDestroyBuffer()`, `vkDestroyImage()`,

-`vkCreateBuffer()`, `vkCreateImage()` for that purpose and NOT vmaDestroyBuffer(),

-vmaDestroyImage(), vmaCreateBuffer(), vmaCreateImage()! Example:

-

-\code

-VkDevice device = ...;

-VmaAllocator allocator = ...;

-std::vector<VkBuffer> buffers = ...;

-std::vector<VmaAllocation> allocations = ...;

-

-std::vector<VkBool32> allocationsChanged(allocations.size());

-vmaDefragment(allocator, allocations.data(), allocations.size(), allocationsChanged.data(), nullptr, nullptr);

-

-for(size_t i = 0; i < allocations.size(); ++i)

-{

-    if(allocationsChanged[i])

-    {

-        VmaAllocationInfo allocInfo;

-        vmaGetAllocationInfo(allocator, allocations[i], &allocInfo);

-

-        vkDestroyBuffer(device, buffers[i], nullptr);

-

-        VkBufferCreateInfo bufferInfo = ...;

-        vkCreateBuffer(device, &bufferInfo, nullptr, &buffers[i]);

-            

-        // You can make dummy call to vkGetBufferMemoryRequirements here to silence validation layer warning.

-            

-        vkBindBufferMemory(device, buffers[i], allocInfo.deviceMemory, allocInfo.offset);

-    }

-}

-\endcode

-

-Note: Please don't expect memory to be fully compacted after this call.

-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 data that

-needs to be moved. Some fragmentation still remains after this call. This is normal.

-

-Warning: This function is not 100% correct according to Vulkan specification. Use it

-at your own risk. That's because Vulkan doesn't guarantee that memory

-requirements (size and alignment) for a new buffer or image are consistent. They

-may be different even for subsequent calls with the same parameters. It really

-does happen on some platforms, especially with images.

-

-Warning: This function may be time-consuming, so you shouldn't call it too often

-(like every frame or 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).

-*/

-VkResult vmaDefragment(

-    VmaAllocator allocator,

-    VmaAllocation* pAllocations,

-    size_t allocationCount,

-    VkBool32* pAllocationsChanged,

-    const VmaDefragmentationInfo *pDefragmentationInfo,

-    VmaDefragmentationStats* 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.

-*/

-VkResult vmaBindBufferMemory(

-    VmaAllocator allocator,

-    VmaAllocation allocation,

-    VkBuffer buffer);

-

-/** \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.

-*/

-VkResult vmaBindImageMemory(

-    VmaAllocator allocator,

-    VmaAllocation allocation,

-    VkImage image);

-

-/**

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

-*/

-VkResult vmaCreateBuffer(

-    VmaAllocator allocator,

-    const VkBufferCreateInfo* pBufferCreateInfo,

-    const VmaAllocationCreateInfo* pAllocationCreateInfo,

-    VkBuffer* pBuffer,

-    VmaAllocation* pAllocation,

-    VmaAllocationInfo* 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.

-*/

-void vmaDestroyBuffer(

-    VmaAllocator allocator,

-    VkBuffer buffer,

-    VmaAllocation allocation);

-

-/// Function similar to vmaCreateBuffer().

-VkResult vmaCreateImage(

-    VmaAllocator allocator,

-    const VkImageCreateInfo* pImageCreateInfo,

-    const VmaAllocationCreateInfo* pAllocationCreateInfo,

-    VkImage* pImage,

-    VmaAllocation* pAllocation,

-    VmaAllocationInfo* 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.

-*/

-void vmaDestroyImage(

-    VmaAllocator allocator,

-    VkImage image,

-    VmaAllocation allocation);

-

-#ifdef __cplusplus

-}

-#endif

-

-#endif // AMD_VULKAN_MEMORY_ALLOCATOR_H

-

-// For Visual Studio IntelliSense.

-#ifdef __INTELLISENSE__

-#define VMA_IMPLEMENTATION

-#endif

-

-#ifdef VMA_IMPLEMENTATION

-#undef VMA_IMPLEMENTATION

-

-#include <cstdint>

-#include <cstdlib>

-#include <cstring>

-

-/*******************************************************************************

-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;

-

-Define to 0 if you are going to provide you own pointers to Vulkan functions via

-VmaAllocatorCreateInfo::pVulkanFunctions.

-*/

-#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 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

-

-#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> // for std::mutex

-#include <atomic> // for std::atomic

-

-#if !defined(_WIN32) && !defined(__APPLE__)

-    #include <malloc.h> // for aligned_alloc()

-#endif

-

-#ifndef VMA_NULL

-   // Value used as null pointer. Define it to e.g.: nullptr, NULL, 0, (void*)0.

-   #define VMA_NULL   nullptr

-#endif

-

-#if defined(__APPLE__) || defined(__ANDROID__)

-#include <cstdlib>

-void *aligned_alloc(size_t alignment, size_t size)

-{

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

-}

-#endif

-

-// Normal assert to check for programmer's errors, especially in Debug configuration.

-#ifndef VMA_ASSERT

-   #ifdef _DEBUG

-       #define VMA_ASSERT(expr)         assert(expr)

-   #else

-       #define VMA_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 _DEBUG

-       #define VMA_HEAVY_ASSERT(expr)   //VMA_ASSERT(expr)

-   #else

-       #define VMA_HEAVY_ASSERT(expr)

-   #endif

-#endif

-

-#ifndef VMA_ALIGN_OF

-   #define VMA_ALIGN_OF(type)       (__alignof(type))

-#endif

-

-#ifndef VMA_SYSTEM_ALIGNED_MALLOC

-   #if defined(_WIN32)

-       #define VMA_SYSTEM_ALIGNED_MALLOC(size, alignment)   (_aligned_malloc((size), (alignment)))

-   #else

-       #define VMA_SYSTEM_ALIGNED_MALLOC(size, alignment)   (aligned_alloc((alignment), (size) ))

-   #endif

-#endif

-

-#ifndef VMA_SYSTEM_FREE

-   #if defined(_WIN32)

-       #define VMA_SYSTEM_FREE(ptr)   _aligned_free(ptr)

-   #else

-       #define VMA_SYSTEM_FREE(ptr)   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:

-       VmaMutex() { }

-       ~VmaMutex() { }

-       void Lock() { m_Mutex.lock(); }

-       void Unlock() { m_Mutex.unlock(); }

-   private:

-       std::mutex m_Mutex;

-   };

-   #define VMA_MUTEX VmaMutex

-#endif

-

-/*

-If providing your own implementation, you need to implement a subset of std::atomic:

-

-- Constructor(uint32_t desired)

-- uint32_t load() const

-- void store(uint32_t desired)

-- bool compare_exchange_weak(uint32_t& expected, uint32_t desired)

-*/

-#ifndef VMA_ATOMIC_UINT32

-   #define VMA_ATOMIC_UINT32 std::atomic<uint32_t>

-#endif

-

-#ifndef VMA_BEST_FIT

-   /**

-   Main parameter for function assessing how good is a free suballocation for a new

-   allocation request.

-

-   - Set to 1 to use Best-Fit algorithm - prefer smaller blocks, as close to the

-     size of requested allocations as possible.

-   - Set to 0 to use Worst-Fit algorithm - prefer larger blocks, as large as

-     possible.

-

-   Experiments in special testing environment showed that Best-Fit algorithm is

-   better.

-   */

-   #define VMA_BEST_FIT (1)

-#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 suballocations, 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 between suballocations, in bytes.

-   Set nonzero for debugging purposes only.

-   */

-   #define VMA_DEBUG_MARGIN (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

-

-static const uint32_t VMA_FRAME_INDEX_LOST = UINT32_MAX;

-

-/*******************************************************************************

-END OF CONFIGURATION

-*/

-

-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;

-}

-

-// 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 align)

-{

-	return (val + align - 1) / align * align;

-}

-

-// Division with mathematical rounding to nearest number.

-template <typename T>

-inline T VmaRoundDiv(T x, T y)

-{

-	return (x + (y / (T)2)) / y;

-}

-

-#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;

-    }

-}

-

-// Helper RAII class to lock a mutex in constructor and unlock it in destructor (at the end of scope).

-struct VmaMutexLock

-{

-public:

-    VmaMutexLock(VMA_MUTEX& mutex, bool useMutex) :

-        m_pMutex(useMutex ? &mutex : VMA_NULL)

-    {

-        if(m_pMutex)

-        {

-            m_pMutex->Lock();

-        }

-    }

-    

-    ~VmaMutexLock()

-    {

-        if(m_pMutex)

-        {

-            m_pMutex->Unlock();

-        }

-    }

-

-private:

-    VMA_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 IterT, typename KeyT, typename CmpT>

-static IterT VmaBinaryFindFirstNotLess(IterT beg, IterT end, const KeyT &key, CmpT cmp)

-{

-   size_t down = 0, up = (end - beg);

-   while(down < up)

-   {

-      const size_t mid = (down + up) / 2;

-      if(cmp(*(beg+mid), key))

-      {

-         down = mid + 1;

-      }

-      else

-      {

-         up = mid;

-      }

-   }

-   return beg + down;

-}

-

-////////////////////////////////////////////////////////////////////////////////

-// Memory allocation

-

-static void* VmaMalloc(const VkAllocationCallbacks* pAllocationCallbacks, size_t size, size_t alignment)

-{

-    if((pAllocationCallbacks != VMA_NULL) &&

-        (pAllocationCallbacks->pfnAllocation != VMA_NULL))

-    {

-        return (*pAllocationCallbacks->pfnAllocation)(

-            pAllocationCallbacks->pUserData,

-            size,

-            alignment,

-            VK_SYSTEM_ALLOCATION_SCOPE_OBJECT);

-    }

-    else

-    {

-        return VMA_SYSTEM_ALIGNED_MALLOC(size, alignment);

-    }

-}

-

-static void VmaFree(const VkAllocationCallbacks* pAllocationCallbacks, void* ptr)

-{

-    if((pAllocationCallbacks != VMA_NULL) &&

-        (pAllocationCallbacks->pfnFree != VMA_NULL))

-    {

-        (*pAllocationCallbacks->pfnFree)(pAllocationCallbacks->pUserData, ptr);

-    }

-    else

-    {

-        VMA_SYSTEM_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);

-    }

-}

-

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

-    {

-    }

-    

-    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;

-}

-

-template<typename CmpLess, typename VectorT>

-size_t VmaVectorFindSorted(const VectorT& vector, const typename VectorT::value_type& value)

-{

-    CmpLess comparator;

-    typename VectorT::iterator it = VmaBinaryFindFirstNotLess(

-        vector.data(),

-        vector.data() + vector.size(),

-        value,

-        comparator);

-    if(it != vector.size() && !comparator(*it, value) && !comparator(value, *it))

-    {

-        return it - vector.begin();

-    }

-    else

-    {

-        return vector.size();

-    }

-}

-

-////////////////////////////////////////////////////////////////////////////////

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

-{

-public:

-    VmaPoolAllocator(const VkAllocationCallbacks* pAllocationCallbacks, size_t itemsPerBlock);

-    ~VmaPoolAllocator();

-    void Clear();

-    T* Alloc();

-    void Free(T* ptr);

-

-private:

-    union Item

-    {

-        uint32_t NextFreeIndex;

-        T Value;

-    };

-

-    struct ItemBlock

-    {

-        Item* pItems;

-        uint32_t FirstFreeIndex;

-    };

-    

-    const VkAllocationCallbacks* m_pAllocationCallbacks;

-    size_t m_ItemsPerBlock;

-    VmaVector< ItemBlock, VmaStlAllocator<ItemBlock> > m_ItemBlocks;

-

-    ItemBlock& CreateNewBlock();

-};

-

-template<typename T>

-VmaPoolAllocator<T>::VmaPoolAllocator(const VkAllocationCallbacks* pAllocationCallbacks, size_t itemsPerBlock) :

-    m_pAllocationCallbacks(pAllocationCallbacks),

-    m_ItemsPerBlock(itemsPerBlock),

-    m_ItemBlocks(VmaStlAllocator<ItemBlock>(pAllocationCallbacks))

-{

-    VMA_ASSERT(itemsPerBlock > 0);

-}

-

-template<typename T>

-VmaPoolAllocator<T>::~VmaPoolAllocator()

-{

-    Clear();

-}

-

-template<typename T>

-void VmaPoolAllocator<T>::Clear()

-{

-    for(size_t i = m_ItemBlocks.size(); i--; )

-        vma_delete_array(m_pAllocationCallbacks, m_ItemBlocks[i].pItems, m_ItemsPerBlock);

-    m_ItemBlocks.clear();

-}

-

-template<typename T>

-T* VmaPoolAllocator<T>::Alloc()

-{

-    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;

-            return &pItem->Value;

-        }

-    }

-

-    // No block has free item: Create new one and use it.

-    ItemBlock& newBlock = CreateNewBlock();

-    Item* const pItem = &newBlock.pItems[0];

-    newBlock.FirstFreeIndex = pItem->NextFreeIndex;

-    return &pItem->Value;

-}

-

-template<typename T>

-void VmaPoolAllocator<T>::Free(T* ptr)

-{

-    // Search all memory blocks to find ptr.

-    for(size_t i = 0; 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 + m_ItemsPerBlock))

-        {

-            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()

-{

-    ItemBlock newBlock = {

-        vma_new_array(m_pAllocationCallbacks, Item, m_ItemsPerBlock), 0 };

-

-    m_ItemBlocks.push_back(newBlock);

-

-    // Setup singly-linked list of all free items in this block.

-    for(uint32_t i = 0; i < m_ItemsPerBlock - 1; ++i)

-        newBlock.pItems[i].NextFreeIndex = i + 1;

-    newBlock.pItems[m_ItemsPerBlock - 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

-{

-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;

-

-    // Declared not defined, to block copy constructor and assignment operator.

-    VmaRawList(const VmaRawList<T>& src);

-    VmaRawList<T>& operator=(const VmaRawList<T>& rhs);

-};

-

-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

-{

-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;

-

-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,

-    };

-

-    VmaAllocation_T(uint32_t currentFrameIndex, bool userDataString) :

-        m_Alignment(1),

-        m_Size(0),

-        m_pUserData(VMA_NULL),

-        m_LastUseFrameIndex(currentFrameIndex),

-        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 : 0)

-    {

-    }

-

-    ~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(

-        VmaPool hPool,

-        VmaDeviceMemoryBlock* block,

-        VkDeviceSize offset,

-        VkDeviceSize alignment,

-        VkDeviceSize size,

-        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_MapCount = mapped ? MAP_COUNT_FLAG_PERSISTENT_MAP : 0;

-        m_SuballocationType = (uint8_t)suballocationType;

-        m_BlockAllocation.m_hPool = hPool;

-        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_BlockAllocation.m_hPool = VK_NULL_HANDLE;

-        m_BlockAllocation.m_Block = VMA_NULL;

-        m_BlockAllocation.m_Offset = 0;

-        m_BlockAllocation.m_CanBecomeLost = true;

-    }

-

-    void ChangeBlockAllocation(

-        VmaAllocator hAllocator,

-        VmaDeviceMemoryBlock* block,

-        VkDeviceSize offset);

-

-    // 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_SuballocationType = (uint8_t)suballocationType;

-        m_MapCount = (pMappedData != VMA_NULL) ? MAP_COUNT_FLAG_PERSISTENT_MAP : 0;

-        m_DedicatedAllocation.m_MemoryTypeIndex = memoryTypeIndex;

-        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;

-    bool IsPersistentMap() const { return (m_MapCount & MAP_COUNT_FLAG_PERSISTENT_MAP) != 0; }

-    void* GetMappedData() const;

-    bool CanBecomeLost() const;

-    VmaPool GetPool() 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);

-

-private:

-    VkDeviceSize m_Alignment;

-    VkDeviceSize m_Size;

-    void* m_pUserData;

-    VMA_ATOMIC_UINT32 m_LastUseFrameIndex;

-    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

-    {

-        VmaPool m_hPool; // Null if belongs to general memory.

-        VmaDeviceMemoryBlock* m_Block;

-        VkDeviceSize m_Offset;

-        bool m_CanBecomeLost;

-    };

-

-    // Allocation for an object that has its own private VkDeviceMemory.

-    struct DedicatedAllocation

-    {

-        uint32_t m_MemoryTypeIndex;

-        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;

-    };

-

-    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;

-};

-

-typedef VmaList< VmaSuballocation, VmaStlAllocator<VmaSuballocation> > VmaSuballocationList;

-

-// Cost of one additional allocation lost, as equivalent in bytes.

-static const VkDeviceSize VMA_LOST_ALLOCATION_COST = 1048576;

-

-/*

-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;

-

-    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);

-    ~VmaBlockMetadata();

-    void Init(VkDeviceSize size);

-

-    // Validates all data structures inside this object. If not valid, returns false.

-    bool Validate() const;

-    VkDeviceSize GetSize() const { return m_Size; }

-    size_t GetAllocationCount() const { return m_Suballocations.size() - m_FreeCount; }

-    VkDeviceSize GetSumFreeSize() const { return m_SumFreeSize; }

-    VkDeviceSize GetUnusedRangeSizeMax() const;

-    // Returns true if this block is empty - contains only single free suballocation.

-    bool IsEmpty() const;

-

-    void CalcAllocationStatInfo(VmaStatInfo& outInfo) const;

-    void AddPoolStats(VmaPoolStats& inoutStats) const;

-

-#if VMA_STATS_STRING_ENABLED

-    void PrintDetailedMap(class VmaJsonWriter& json) const;

-#endif

-

-    // Creates trivial request for case when block is empty.

-    void CreateFirstAllocationRequest(VmaAllocationRequest* pAllocationRequest);

-

-    // Tries to find a place for suballocation with given parameters inside this block.

-    // If succeeded, fills pAllocationRequest and returns true.

-    // If failed, returns false.

-    bool CreateAllocationRequest(

-        uint32_t currentFrameIndex,

-        uint32_t frameInUseCount,

-        VkDeviceSize bufferImageGranularity,

-        VkDeviceSize allocSize,

-        VkDeviceSize allocAlignment,

-        VmaSuballocationType allocType,

-        bool canMakeOtherLost,

-        VmaAllocationRequest* pAllocationRequest);

-

-    bool MakeRequestedAllocationsLost(

-        uint32_t currentFrameIndex,

-        uint32_t frameInUseCount,

-        VmaAllocationRequest* pAllocationRequest);

-

-    uint32_t MakeAllocationsLost(uint32_t currentFrameIndex, uint32_t frameInUseCount);

-

-    // Makes actual allocation based on request. Request must already be checked and valid.

-    void Alloc(

-        const VmaAllocationRequest& request,

-        VmaSuballocationType type,

-        VkDeviceSize allocSize,

-        VmaAllocation hAllocation);

-

-    // Frees suballocation assigned to given memory region.

-    void Free(const VmaAllocation allocation);

-    void FreeAtOffset(VkDeviceSize offset);

-

-private:

-    VkDeviceSize m_Size;

-    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);

-};

-

-/*

-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

-{

-public:

-    VmaBlockMetadata m_Metadata;

-

-    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(

-        uint32_t newMemoryTypeIndex,

-        VkDeviceMemory newMemory,

-        VkDeviceSize newSize);

-    // Always call before destruction.

-    void Destroy(VmaAllocator allocator);

-    

-    VkDeviceMemory GetDeviceMemory() const { return m_hMemory; }

-    uint32_t GetMemoryTypeIndex() const { return m_MemoryTypeIndex; }

-    void* GetMappedData() const { return m_pMappedData; }

-

-    // Validates all data structures inside this object. If not valid, returns false.

-    bool Validate() const;

-

-    // ppData can be null.

-    VkResult Map(VmaAllocator hAllocator, uint32_t count, void** ppData);

-    void Unmap(VmaAllocator hAllocator, uint32_t count);

-

-    VkResult BindBufferMemory(

-        const VmaAllocator hAllocator,

-        const VmaAllocation hAllocation,

-        VkBuffer hBuffer);

-    VkResult BindImageMemory(

-        const VmaAllocator hAllocator,

-        const VmaAllocation hAllocation,

-        VkImage hImage);

-

-private:

-    uint32_t m_MemoryTypeIndex;

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

-    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;

-    }

-};

-

-class VmaDefragmentator;

-

-/*

-Sequence of VmaDeviceMemoryBlock. Represents memory blocks allocated for a specific

-Vulkan memory type.

-

-Synchronized internally with a mutex.

-*/

-struct VmaBlockVector

-{

-    VmaBlockVector(

-        VmaAllocator hAllocator,

-        uint32_t memoryTypeIndex,

-        VkDeviceSize preferredBlockSize,

-        size_t minBlockCount,

-        size_t maxBlockCount,

-        VkDeviceSize bufferImageGranularity,

-        uint32_t frameInUseCount,

-        bool isCustomPool);

-    ~VmaBlockVector();

-

-    VkResult CreateMinBlocks();

-

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

-

-    void GetPoolStats(VmaPoolStats* pStats);

-

-    bool IsEmpty() const { return m_Blocks.empty(); }

-

-    VkResult Allocate(

-        VmaPool hCurrentPool,

-        uint32_t currentFrameIndex,

-        const VkMemoryRequirements& vkMemReq,

-        const VmaAllocationCreateInfo& createInfo,

-        VmaSuballocationType suballocType,

-        VmaAllocation* pAllocation);

-

-    void Free(

-        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);

-

-    VmaDefragmentator* EnsureDefragmentator(

-        VmaAllocator hAllocator,

-        uint32_t currentFrameIndex);

-

-    VkResult Defragment(

-        VmaDefragmentationStats* pDefragmentationStats,

-        VkDeviceSize& maxBytesToMove,

-        uint32_t& maxAllocationsToMove);

-

-    void DestroyDefragmentator();

-

-private:

-    friend class VmaDefragmentator;

-

-    const VmaAllocator m_hAllocator;

-    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_IsCustomPool;

-    VMA_MUTEX m_Mutex;

-    // Incrementally sorted by sumFreeSize, ascending.

-    VmaVector< VmaDeviceMemoryBlock*, VmaStlAllocator<VmaDeviceMemoryBlock*> > m_Blocks;

-    /* There can be at most one allocation that is completely empty - a

-    hysteresis to avoid pessimistic case of alternating creation and destruction

-    of a VkDeviceMemory. */

-    bool m_HasEmptyBlock;

-    VmaDefragmentator* m_pDefragmentator;

-

-    size_t 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 CreateBlock(VkDeviceSize blockSize, size_t* pNewBlockIndex);

-};

-

-struct VmaPool_T

-{

-public:

-    VmaBlockVector m_BlockVector;

-

-    // Takes ownership.

-    VmaPool_T(

-        VmaAllocator hAllocator,

-        const VmaPoolCreateInfo& createInfo);

-    ~VmaPool_T();

-

-    VmaBlockVector& GetBlockVector() { return m_BlockVector; }

-

-#if VMA_STATS_STRING_ENABLED

-    //void PrintDetailedMap(class VmaStringBuilder& sb);

-#endif

-};

-

-class VmaDefragmentator

-{

-    const VmaAllocator m_hAllocator;

-    VmaBlockVector* const m_pBlockVector;

-    uint32_t m_CurrentFrameIndex;

-    VkDeviceSize m_BytesMoved;

-    uint32_t m_AllocationsMoved;

-

-    struct AllocationInfo

-    {

-        VmaAllocation m_hAllocation;

-        VkBool32* m_pChanged;

-

-        AllocationInfo() :

-            m_hAllocation(VK_NULL_HANDLE),

-            m_pChanged(VMA_NULL)

-        {

-        }

-    };

-

-    struct AllocationInfoSizeGreater

-    {

-        bool operator()(const AllocationInfo& lhs, const AllocationInfo& rhs) const

-        {

-            return lhs.m_hAllocation->GetSize() > rhs.m_hAllocation->GetSize();

-        }

-    };

-

-    // Used between AddAllocation and Defragment.

-    VmaVector< AllocationInfo, VmaStlAllocator<AllocationInfo> > m_Allocations;

-

-    struct BlockInfo

-    {

-        VmaDeviceMemoryBlock* m_pBlock;

-        bool m_HasNonMovableAllocations;

-        VmaVector< AllocationInfo, VmaStlAllocator<AllocationInfo> > m_Allocations;

-

-        BlockInfo(const VkAllocationCallbacks* pAllocationCallbacks) :

-            m_pBlock(VMA_NULL),

-            m_HasNonMovableAllocations(true),

-            m_Allocations(pAllocationCallbacks),

-            m_pMappedDataForDefragmentation(VMA_NULL)

-        {

-        }

-

-        void CalcHasNonMovableAllocations()

-        {

-            const size_t blockAllocCount = m_pBlock->m_Metadata.GetAllocationCount();

-            const size_t defragmentAllocCount = m_Allocations.size();

-            m_HasNonMovableAllocations = blockAllocCount != defragmentAllocCount;

-        }

-

-        void SortAllocationsBySizeDescecnding()

-        {

-            VMA_SORT(m_Allocations.begin(), m_Allocations.end(), AllocationInfoSizeGreater());

-        }

-

-        VkResult EnsureMapping(VmaAllocator hAllocator, void** ppMappedData);

-        void Unmap(VmaAllocator hAllocator);

-

-    private:

-        // Not null if mapped for defragmentation only, not originally mapped.

-        void* m_pMappedDataForDefragmentation;

-    };

-

-    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_Metadata.GetSumFreeSize() < pRhsBlockInfo->m_pBlock->m_Metadata.GetSumFreeSize())

-            {

-                return true;

-            }

-            return false;

-        }

-    };

-

-    typedef VmaVector< BlockInfo*, VmaStlAllocator<BlockInfo*> > BlockInfoVector;

-    BlockInfoVector m_Blocks;

-

-    VkResult DefragmentRound(

-        VkDeviceSize maxBytesToMove,

-        uint32_t maxAllocationsToMove);

-

-    static bool MoveMakesSense(

-        size_t dstBlockIndex, VkDeviceSize dstOffset,

-        size_t srcBlockIndex, VkDeviceSize srcOffset);

-

-public:

-    VmaDefragmentator(

-        VmaAllocator hAllocator,

-        VmaBlockVector* pBlockVector,

-        uint32_t currentFrameIndex);

-

-    ~VmaDefragmentator();

-

-    VkDeviceSize GetBytesMoved() const { return m_BytesMoved; }

-    uint32_t GetAllocationsMoved() const { return m_AllocationsMoved; }

-

-    void AddAllocation(VmaAllocation hAlloc, VkBool32* pChanged);

-

-    VkResult Defragment(

-        VkDeviceSize maxBytesToMove,

-        uint32_t maxAllocationsToMove);

-};

-

-// Main allocator object.

-struct VmaAllocator_T

-{

-    bool m_UseMutex;

-    bool m_UseKhrDedicatedAllocation;

-    VkDevice m_hDevice;

-    bool m_AllocationCallbacksSpecified;

-    VkAllocationCallbacks m_AllocationCallbacks;

-    VmaDeviceMemoryCallbacks m_DeviceMemoryCallbacks;

-    

-    // Number of bytes free out of limit, or VK_WHOLE_SIZE if not limit for that heap.

-    VkDeviceSize m_HeapSizeLimit[VK_MAX_MEMORY_HEAPS];

-    VMA_MUTEX m_HeapSizeLimitMutex;

-

-    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_MUTEX m_DedicatedAllocationsMutex[VK_MAX_MEMORY_TYPES];

-

-    VmaAllocator_T(const VmaAllocatorCreateInfo* pCreateInfo);

-    ~VmaAllocator_T();

-

-    const VkAllocationCallbacks* GetAllocationCallbacks() const

-    {

-        return m_AllocationCallbacksSpecified ? &m_AllocationCallbacks : 0;

-    }

-    const VmaVulkanFunctions& GetVulkanFunctions() const

-    {

-        return m_VulkanFunctions;

-    }

-

-    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;

-    }

-

-    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,

-        VkImage dedicatedImage,

-        const VmaAllocationCreateInfo& createInfo,

-        VmaSuballocationType suballocType,

-        VmaAllocation* pAllocation);

-

-    // Main deallocation function.

-    void FreeMemory(const VmaAllocation allocation);

-

-    void CalculateStats(VmaStats* pStats);

-

-#if VMA_STATS_STRING_ENABLED

-    void PrintDetailedMap(class VmaJsonWriter& json);

-#endif

-

-    VkResult Defragment(

-        VmaAllocation* pAllocations,

-        size_t allocationCount,

-        VkBool32* pAllocationsChanged,

-        const VmaDefragmentationInfo* pDefragmentationInfo,

-        VmaDefragmentationStats* pDefragmentationStats);

-

-    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);

-

-    void MakePoolAllocationsLost(

-        VmaPool hPool,

-        size_t* pLostAllocationCount);

-

-    void CreateLostAllocation(VmaAllocation* pAllocation);

-

-    VkResult AllocateVulkanMemory(const VkMemoryAllocateInfo* pAllocateInfo, VkDeviceMemory* pMemory);

-    void FreeVulkanMemory(uint32_t memoryType, VkDeviceSize size, VkDeviceMemory hMemory);

-

-    VkResult Map(VmaAllocation hAllocation, void** ppData);

-    void Unmap(VmaAllocation hAllocation);

-

-    VkResult BindBufferMemory(VmaAllocation hAllocation, VkBuffer hBuffer);

-    VkResult BindImageMemory(VmaAllocation hAllocation, VkImage hImage);

-

-private:

-    VkDeviceSize m_PreferredLargeHeapBlockSize;

-

-    VkPhysicalDevice m_PhysicalDevice;

-    VMA_ATOMIC_UINT32 m_CurrentFrameIndex;

-    

-    VMA_MUTEX m_PoolsMutex;

-    // Protected by m_PoolsMutex. Sorted by pointer value.

-    VmaVector<VmaPool, VmaStlAllocator<VmaPool> > m_Pools;

-

-    VmaVulkanFunctions m_VulkanFunctions;

-

-    void ImportVulkanFunctions(const VmaVulkanFunctions* pVulkanFunctions);

-

-    VkDeviceSize CalcPreferredBlockSize(uint32_t memTypeIndex);

-

-    VkResult AllocateMemoryOfType(

-        const VkMemoryRequirements& vkMemReq,

-        bool dedicatedAllocation,

-        VkBuffer dedicatedBuffer,

-        VkImage dedicatedImage,

-        const VmaAllocationCreateInfo& createInfo,

-        uint32_t memTypeIndex,

-        VmaSuballocationType suballocType,

-        VmaAllocation* pAllocation);

-

-    // Allocates and registers new VkDeviceMemory specifically for single allocation.

-    VkResult AllocateDedicatedMemory(

-        VkDeviceSize size,

-        VmaSuballocationType suballocType,

-        uint32_t memTypeIndex,

-        bool map,

-        bool isUserDataString,

-        void* pUserData,

-        VkBuffer dedicatedBuffer,

-        VkImage dedicatedImage,

-        VmaAllocation* pAllocation);

-

-    // Tries to free pMemory as Dedicated Memory. Returns true if found and freed.

-    void FreeDedicatedMemory(VmaAllocation allocation);

-};

-

-////////////////////////////////////////////////////////////////////////////////

-// 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];

-    VmaUint32ToStr(buf, sizeof(buf), num);

-    Add(buf);

-}

-

-void VmaStringBuilder::AddNumber(uint64_t num)

-{

-    char buf[21];

-    VmaUint64ToStr(buf, sizeof(buf), num);

-    Add(buf);

-}

-

-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

-{

-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)

-        {

-            const char* const newStrSrc = (char*)pUserData;

-            const size_t newStrLen = strlen(newStrSrc);

-            char* const newStrDst = vma_new_array(hAllocator, char, newStrLen + 1);

-            memcpy(newStrDst, newStrSrc, newStrLen + 1);

-            m_pUserData = newStrDst;

-        }

-    }

-    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;

-}

-

-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;

-    }

-}

-

-uint32_t VmaAllocation_T::GetMemoryTypeIndex() const

-{

-    switch(m_Type)

-    {

-    case ALLOCATION_TYPE_BLOCK:

-        return m_BlockAllocation.m_Block->GetMemoryTypeIndex();

-    case ALLOCATION_TYPE_DEDICATED:

-        return m_DedicatedAllocation.m_MemoryTypeIndex;

-    default:

-        VMA_ASSERT(0);

-        return UINT32_MAX;

-    }

-}

-

-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;

-    }

-}

-

-VmaPool VmaAllocation_T::GetPool() const

-{

-    VMA_ASSERT(m_Type == ALLOCATION_TYPE_BLOCK);

-    return m_BlockAllocation.m_hPool;

-}

-

-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;

-            }

-        }

-    }

-}

-

-void VmaAllocation_T::FreeUserDataString(VmaAllocator hAllocator)

-{

-    VMA_ASSERT(IsUserDataString());

-    if(m_pUserData != VMA_NULL)

-    {

-        char* const oldStr = (char*)m_pUserData;

-        const size_t oldStrLen = strlen(oldStr);

-        vma_delete_array(hAllocator, oldStr, oldStrLen + 1);

-        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

-

-// Correspond to values of enum VmaSuballocationType.

-static const char* VMA_SUBALLOCATION_TYPE_NAMES[] = {

-    "FREE",

-    "UNKNOWN",

-    "BUFFER",

-    "IMAGE_UNKNOWN",

-    "IMAGE_LINEAR",

-    "IMAGE_OPTIMAL",

-};

-

-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_FreeCount(0),

-    m_SumFreeSize(0),

-    m_Suballocations(VmaStlAllocator<VmaSuballocation>(hAllocator->GetAllocationCallbacks())),

-    m_FreeSuballocationsBySize(VmaStlAllocator<VmaSuballocationList::iterator>(hAllocator->GetAllocationCallbacks()))

-{

-}

-

-VmaBlockMetadata::~VmaBlockMetadata()

-{

-}

-

-void VmaBlockMetadata::Init(VkDeviceSize size)

-{

-    m_Size = 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;

-

-    m_Suballocations.push_back(suballoc);

-    VmaSuballocationList::iterator suballocItem = m_Suballocations.end();

-    --suballocItem;

-    m_FreeSuballocationsBySize.push_back(suballocItem);

-}

-

-bool VmaBlockMetadata::Validate() const

-{

-    if(m_Suballocations.empty())

-    {

-        return false;

-    }

-    

-    // Expected offset of new suballocation as calculates 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 visisted 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.

-        if(subAlloc.offset != calculatedOffset)

-        {

-            return false;

-        }

-

-        const bool currFree = (subAlloc.type == VMA_SUBALLOCATION_TYPE_FREE);

-        // Two adjacent free suballocations are invalid. They should be merged.

-        if(prevFree && currFree)

-        {

-            return false;

-        }

-

-        if(currFree != (subAlloc.hAllocation == VK_NULL_HANDLE))

-        {

-            return false;

-        }

-

-        if(currFree)

-        {

-            calculatedSumFreeSize += subAlloc.size;

-            ++calculatedFreeCount;

-            if(subAlloc.size >= VMA_MIN_FREE_SUBALLOCATION_SIZE_TO_REGISTER)

-            {

-                ++freeSuballocationsToRegister;

-            }

-        }

-        else

-        {

-            if(subAlloc.hAllocation->GetOffset() != subAlloc.offset)

-            {

-                return false;

-            }

-            if(subAlloc.hAllocation->GetSize() != subAlloc.size)

-            {

-                return false;

-            }

-        }

-

-        calculatedOffset += subAlloc.size;

-        prevFree = currFree;

-    }

-

-    // Number of free suballocations registered in m_FreeSuballocationsBySize doesn't

-    // match expected one.

-    if(m_FreeSuballocationsBySize.size() != freeSuballocationsToRegister)

-    {

-        return false;

-    }

-

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

-        if(suballocItem->type != VMA_SUBALLOCATION_TYPE_FREE)

-        {

-            return false;

-        }

-        // They must be sorted by size ascending.

-        if(suballocItem->size < lastSize)

-        {

-            return false;

-        }

-

-        lastSize = suballocItem->size;

-    }

-

-    // Check if totals match calculacted values.

-    if(!ValidateFreeSuballocationList() ||

-        (calculatedOffset != m_Size) ||

-        (calculatedSumFreeSize != m_SumFreeSize) ||

-        (calculatedFreeCount != m_FreeCount))

-    {

-        return false;

-    }

-

-    return true;

-}

-

-VkDeviceSize VmaBlockMetadata::GetUnusedRangeSizeMax() const

-{

-    if(!m_FreeSuballocationsBySize.empty())

-    {

-        return m_FreeSuballocationsBySize.back()->size;

-    }

-    else

-    {

-        return 0;

-    }

-}

-

-bool VmaBlockMetadata::IsEmpty() const

-{

-    return (m_Suballocations.size() == 1) && (m_FreeCount == 1);

-}

-

-void VmaBlockMetadata::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 = m_Size - 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::AddPoolStats(VmaPoolStats& inoutStats) const

-{

-    const uint32_t rangeCount = (uint32_t)m_Suballocations.size();

-

-    inoutStats.size += m_Size;

-    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::PrintDetailedMap(class VmaJsonWriter& json) const

-{

-    json.BeginObject();

-

-    json.WriteString("TotalBytes");

-    json.WriteNumber(m_Size);

-

-    json.WriteString("UnusedBytes");

-    json.WriteNumber(m_SumFreeSize);

-

-    json.WriteString("Allocations");

-    json.WriteNumber((uint64_t)m_Suballocations.size() - m_FreeCount);

-

-    json.WriteString("UnusedRanges");

-    json.WriteNumber(m_FreeCount);

-

-    json.WriteString("Suballocations");

-    json.BeginArray();

-    size_t i = 0;

-    for(VmaSuballocationList::const_iterator suballocItem = m_Suballocations.cbegin();

-        suballocItem != m_Suballocations.cend();

-        ++suballocItem, ++i)

-    {

-        json.BeginObject(true);

-        

-        json.WriteString("Type");

-        json.WriteString(VMA_SUBALLOCATION_TYPE_NAMES[suballocItem->type]);

-

-        json.WriteString("Size");

-        json.WriteNumber(suballocItem->size);

-

-        json.WriteString("Offset");

-        json.WriteNumber(suballocItem->offset);

-

-        if(suballocItem->type != VMA_SUBALLOCATION_TYPE_FREE)

-        {

-            const void* pUserData = suballocItem->hAllocation->GetUserData();

-            if(pUserData != VMA_NULL)

-            {

-                json.WriteString("UserData");

-                if(suballocItem->hAllocation->IsUserDataString())

-                {

-                    json.WriteString((const char*)pUserData);

-                }

-                else

-                {

-                    json.BeginString();

-                    json.ContinueString_Pointer(pUserData);

-                    json.EndString();

-                }

-            }

-        }

-

-        json.EndObject();

-    }

-    json.EndArray();

-

-    json.EndObject();

-}

-

-#endif // #if VMA_STATS_STRING_ENABLED

-

-/*

-How many suitable free suballocations to analyze before choosing best one.

-- Set to 1 to use First-Fit algorithm - first suitable free suballocation will

-  be chosen.

-- Set to UINT32_MAX to use Best-Fit/Worst-Fit algorithm - all suitable free

-  suballocations will be analized and best one will be chosen.

-- Any other value is also acceptable.

-*/

-//static const uint32_t MAX_SUITABLE_SUBALLOCATIONS_TO_CHECK = 8;

-

-void VmaBlockMetadata::CreateFirstAllocationRequest(VmaAllocationRequest* pAllocationRequest)

-{

-    VMA_ASSERT(IsEmpty());

-    pAllocationRequest->offset = 0;

-    pAllocationRequest->sumFreeSize = m_SumFreeSize;

-    pAllocationRequest->sumItemSize = 0;

-    pAllocationRequest->item = m_Suballocations.begin();

-    pAllocationRequest->itemsToMakeLostCount = 0;

-}

-

-bool VmaBlockMetadata::CreateAllocationRequest(

-    uint32_t currentFrameIndex,

-    uint32_t frameInUseCount,

-    VkDeviceSize bufferImageGranularity,

-    VkDeviceSize allocSize,

-    VkDeviceSize allocAlignment,

-    VmaSuballocationType allocType,

-    bool canMakeOtherLost,

-    VmaAllocationRequest* pAllocationRequest)

-{

-    VMA_ASSERT(allocSize > 0);

-    VMA_ASSERT(allocType != VMA_SUBALLOCATION_TYPE_FREE);

-    VMA_ASSERT(pAllocationRequest != VMA_NULL);

-    VMA_HEAVY_ASSERT(Validate());

-

-    // There is not enough total free space in this block to fullfill the request: Early return.

-    if(canMakeOtherLost == false && m_SumFreeSize < allocSize)

-    {

-        return false;

-    }

-

-    // New algorithm, efficiently searching freeSuballocationsBySize.

-    const size_t freeSuballocCount = m_FreeSuballocationsBySize.size();

-    if(freeSuballocCount > 0)

-    {

-        if(VMA_BEST_FIT)

-        {

-            // Find first free suballocation with size not less than allocSize.

-            VmaSuballocationList::iterator* const it = VmaBinaryFindFirstNotLess(

-                m_FreeSuballocationsBySize.data(),

-                m_FreeSuballocationsBySize.data() + freeSuballocCount,

-                allocSize,

-                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

-        {

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

-

-        pAllocationRequest->sumFreeSize = VK_WHOLE_SIZE;

-        pAllocationRequest->sumItemSize = VK_WHOLE_SIZE;

-

-        VmaAllocationRequest tmpAllocRequest = {};

-        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))

-                {

-                    tmpAllocRequest.item = suballocIt;

-

-                    if(tmpAllocRequest.CalcCost() < pAllocationRequest->CalcCost())

-                    {

-                        *pAllocationRequest = tmpAllocRequest;

-                    }

-                }

-            }

-        }

-

-        if(pAllocationRequest->sumItemSize != VK_WHOLE_SIZE)

-        {

-            return true;

-        }

-    }

-

-    return false;

-}

-

-bool VmaBlockMetadata::MakeRequestedAllocationsLost(

-    uint32_t currentFrameIndex,

-    uint32_t frameInUseCount,

-    VmaAllocationRequest* pAllocationRequest)

-{

-    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::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;

-}

-

-void VmaBlockMetadata::Alloc(

-    const VmaAllocationRequest& request,

-    VmaSuballocationType type,

-    VkDeviceSize allocSize,

-    VmaAllocation hAllocation)

-{

-    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::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::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::ValidateFreeSuballocationList() const

-{

-    VkDeviceSize lastSize = 0;

-    for(size_t i = 0, count = m_FreeSuballocationsBySize.size(); i < count; ++i)

-    {

-        const VmaSuballocationList::iterator it = m_FreeSuballocationsBySize[i];

-

-        if(it->type != VMA_SUBALLOCATION_TYPE_FREE)

-        {

-            VMA_ASSERT(0);

-            return false;

-        }

-        if(it->size < VMA_MIN_FREE_SUBALLOCATION_SIZE_TO_REGISTER)

-        {

-            VMA_ASSERT(0);

-            return false;

-        }

-        if(it->size < lastSize)

-        {

-            VMA_ASSERT(0);

-            return false;

-        }

-

-        lastSize = it->size;

-    }

-    return true;

-}

-

-bool VmaBlockMetadata::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(m_Size - 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) && suballocItem != m_Suballocations.cbegin())

-        {

-            *pOffset += VMA_DEBUG_MARGIN;

-        }

-    

-        // Apply alignment.

-        const VkDeviceSize alignment = VMA_MAX(allocAlignment, static_cast<VkDeviceSize>(VMA_DEBUG_ALIGNMENT));

-        *pOffset = VmaAlignUp(*pOffset, alignment);

-

-        // 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 if this is not last suballocation.

-        VmaSuballocationList::const_iterator next = suballocItem;

-        ++next;

-        const VkDeviceSize requiredEndMargin =

-            (next != m_Suballocations.cend()) ? VMA_DEBUG_MARGIN : 0;

-

-        const VkDeviceSize totalSize = paddingBegin + allocSize + requiredEndMargin;

-        // Another early return check.

-        if(suballocItem->offset + totalSize > m_Size)

-        {

-            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) && suballocItem != m_Suballocations.cbegin())

-        {

-            *pOffset += VMA_DEBUG_MARGIN;

-        }

-    

-        // Apply alignment.

-        const VkDeviceSize alignment = VMA_MAX(allocAlignment, static_cast<VkDeviceSize>(VMA_DEBUG_ALIGNMENT));

-        *pOffset = VmaAlignUp(*pOffset, alignment);

-    

-        // 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 if this is not last suballocation.

-        VmaSuballocationList::const_iterator next = suballocItem;

-        ++next;

-        const VkDeviceSize requiredEndMargin =

-            (next != m_Suballocations.cend()) ? VMA_DEBUG_MARGIN : 0;

-

-        // 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::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::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::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::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());

-}

-

-////////////////////////////////////////////////////////////////////////////////

-// class VmaDeviceMemoryBlock

-

-VmaDeviceMemoryBlock::VmaDeviceMemoryBlock(VmaAllocator hAllocator) :

-    m_Metadata(hAllocator),

-    m_MemoryTypeIndex(UINT32_MAX),

-    m_hMemory(VK_NULL_HANDLE),

-    m_MapCount(0),

-    m_pMappedData(VMA_NULL)

-{

-}

-

-void VmaDeviceMemoryBlock::Init(

-    uint32_t newMemoryTypeIndex,

-    VkDeviceMemory newMemory,

-    VkDeviceSize newSize)

-{

-    VMA_ASSERT(m_hMemory == VK_NULL_HANDLE);

-

-    m_MemoryTypeIndex = newMemoryTypeIndex;

-    m_hMemory = newMemory;

-

-    m_Metadata.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_Metadata.IsEmpty() && "Some allocations were not freed before destruction of this memory block!");

-    

-    VMA_ASSERT(m_hMemory != VK_NULL_HANDLE);

-    allocator->FreeVulkanMemory(m_MemoryTypeIndex, m_Metadata.GetSize(), m_hMemory);

-    m_hMemory = VK_NULL_HANDLE;

-}

-

-bool VmaDeviceMemoryBlock::Validate() const

-{

-    if((m_hMemory == VK_NULL_HANDLE) ||

-        (m_Metadata.GetSize() == 0))

-    {

-        return false;

-    }

-    

-    return m_Metadata.Validate();

-}

-

-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::BindBufferMemory(

-    const VmaAllocator hAllocator,

-    const VmaAllocation hAllocation,

-    VkBuffer hBuffer)

-{

-    VMA_ASSERT(hAllocation->GetType() == VmaAllocation_T::ALLOCATION_TYPE_BLOCK &&

-        hAllocation->GetBlock() == this);

-    // 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->GetVulkanFunctions().vkBindBufferMemory(

-        hAllocator->m_hDevice,

-        hBuffer,

-        m_hMemory,

-        hAllocation->GetOffset());

-}

-

-VkResult VmaDeviceMemoryBlock::BindImageMemory(

-    const VmaAllocator hAllocator,

-    const VmaAllocation hAllocation,

-    VkImage hImage)

-{

-    VMA_ASSERT(hAllocation->GetType() == VmaAllocation_T::ALLOCATION_TYPE_BLOCK &&

-        hAllocation->GetBlock() == this);

-    // 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->GetVulkanFunctions().vkBindImageMemory(

-        hAllocator->m_hDevice,

-        hImage,

-        m_hMemory,

-        hAllocation->GetOffset());

-}

-

-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) :

-    m_BlockVector(

-        hAllocator,

-        createInfo.memoryTypeIndex,

-        createInfo.blockSize,

-        createInfo.minBlockCount,

-        createInfo.maxBlockCount,

-        (createInfo.flags & VMA_POOL_CREATE_IGNORE_BUFFER_IMAGE_GRANULARITY_BIT) != 0 ? 1 : hAllocator->GetBufferImageGranularity(),

-        createInfo.frameInUseCount,

-        true) // isCustomPool

-{

-}

-

-VmaPool_T::~VmaPool_T()

-{

-}

-

-#if VMA_STATS_STRING_ENABLED

-

-#endif // #if VMA_STATS_STRING_ENABLED

-

-VmaBlockVector::VmaBlockVector(

-    VmaAllocator hAllocator,

-    uint32_t memoryTypeIndex,

-    VkDeviceSize preferredBlockSize,

-    size_t minBlockCount,

-    size_t maxBlockCount,

-    VkDeviceSize bufferImageGranularity,

-    uint32_t frameInUseCount,

-    bool isCustomPool) :

-    m_hAllocator(hAllocator),

-    m_MemoryTypeIndex(memoryTypeIndex),

-    m_PreferredBlockSize(preferredBlockSize),

-    m_MinBlockCount(minBlockCount),

-    m_MaxBlockCount(maxBlockCount),

-    m_BufferImageGranularity(bufferImageGranularity),

-    m_FrameInUseCount(frameInUseCount),

-    m_IsCustomPool(isCustomPool),

-    m_Blocks(VmaStlAllocator<VmaDeviceMemoryBlock*>(hAllocator->GetAllocationCallbacks())),

-    m_HasEmptyBlock(false),

-    m_pDefragmentator(VMA_NULL)

-{

-}

-

-VmaBlockVector::~VmaBlockVector()

-{

-    VMA_ASSERT(m_pDefragmentator == VMA_NULL);

-

-    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)

-{

-    pStats->size = 0;

-    pStats->unusedSize = 0;

-    pStats->allocationCount = 0;

-    pStats->unusedRangeCount = 0;

-    pStats->unusedRangeSizeMax = 0;

-

-    VmaMutexLock 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());

-        pBlock->m_Metadata.AddPoolStats(*pStats);

-    }

-}

-

-static const uint32_t VMA_ALLOCATION_TRY_COUNT = 32;

-

-VkResult VmaBlockVector::Allocate(

-    VmaPool hCurrentPool,

-    uint32_t currentFrameIndex,

-    const VkMemoryRequirements& vkMemReq,

-    const VmaAllocationCreateInfo& createInfo,

-    VmaSuballocationType suballocType,

-    VmaAllocation* pAllocation)

-{

-    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;

-

-    VmaMutexLock lock(m_Mutex, m_hAllocator->m_UseMutex);

-

-    // 1. Search existing allocations. Try to allocate without making other allocations lost.

-    // 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_Metadata.CreateAllocationRequest(

-            currentFrameIndex,

-            m_FrameInUseCount,

-            m_BufferImageGranularity,

-            vkMemReq.size,

-            vkMemReq.alignment,

-            suballocType,

-            false, // canMakeOtherLost

-            &currRequest))

-        {

-            // Allocate from pCurrBlock.

-            VMA_ASSERT(currRequest.itemsToMakeLostCount == 0);

-

-            if(mapped)

-            {

-                VkResult res = pCurrBlock->Map(m_hAllocator, 1, VMA_NULL);

-                if(res != VK_SUCCESS)

-                {

-                    return res;

-                }

-            }

-            

-            // We no longer have an empty Allocation.

-            if(pCurrBlock->m_Metadata.IsEmpty())

-            {

-                m_HasEmptyBlock = false;

-            }

-            

-            *pAllocation = vma_new(m_hAllocator, VmaAllocation_T)(currentFrameIndex, isUserDataString);

-            pCurrBlock->m_Metadata.Alloc(currRequest, suballocType, vkMemReq.size, *pAllocation);

-            (*pAllocation)->InitBlockAllocation(

-                hCurrentPool,

-                pCurrBlock,

-                currRequest.offset,

-                vkMemReq.alignment,

-                vkMemReq.size,

-                suballocType,

-                mapped,

-                (createInfo.flags & VMA_ALLOCATION_CREATE_CAN_BECOME_LOST_BIT) != 0);

-            VMA_HEAVY_ASSERT(pCurrBlock->Validate());

-            VMA_DEBUG_LOG("    Returned from existing allocation #%u", (uint32_t)blockIndex);

-            (*pAllocation)->SetUserData(m_hAllocator, createInfo.pUserData);

-            return VK_SUCCESS;

-        }

-    }

-

-    const bool canCreateNewBlock =

-        ((createInfo.flags & VMA_ALLOCATION_CREATE_NEVER_ALLOCATE_BIT) == 0) &&

-        (m_Blocks.size() < m_MaxBlockCount);

-

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

-

-        // Allocating blocks of other sizes is allowed only in default pools.

-        // In custom pools block size is fixed.

-        if(m_IsCustomPool == false)

-        {

-            // 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 >= vkMemReq.size * 2)

-                {

-                    newBlockSize = smallerNewBlockSize;

-                    ++newBlockSizeShift;

-                }

-                else

-                {

-                    break;

-                }

-            }

-        }

-

-        size_t newBlockIndex = 0;

-        VkResult res = CreateBlock(newBlockSize, &newBlockIndex);

-        // Allocation of this size failed? Try 1/2, 1/4, 1/8 of m_PreferredBlockSize.

-        if(m_IsCustomPool == false)

-        {

-            while(res < 0 && newBlockSizeShift < NEW_BLOCK_SIZE_SHIFT_MAX)

-            {

-                const VkDeviceSize smallerNewBlockSize = newBlockSize / 2;

-                if(smallerNewBlockSize >= vkMemReq.size)

-                {

-                    newBlockSize = smallerNewBlockSize;

-                    ++newBlockSizeShift;

-                    res = CreateBlock(newBlockSize, &newBlockIndex);

-                }

-                else

-                {

-                    break;

-                }

-            }

-        }

-

-        if(res == VK_SUCCESS)

-        {

-            VmaDeviceMemoryBlock* const pBlock = m_Blocks[newBlockIndex];

-            VMA_ASSERT(pBlock->m_Metadata.GetSize() >= vkMemReq.size);

-

-            if(mapped)

-            {

-                res = pBlock->Map(m_hAllocator, 1, VMA_NULL);

-                if(res != VK_SUCCESS)

-                {

-                    return res;

-                }

-            }

-

-            // Allocate from pBlock. Because it is empty, dstAllocRequest can be trivially filled.

-            VmaAllocationRequest allocRequest;

-            pBlock->m_Metadata.CreateFirstAllocationRequest(&allocRequest);

-            *pAllocation = vma_new(m_hAllocator, VmaAllocation_T)(currentFrameIndex, isUserDataString);

-            pBlock->m_Metadata.Alloc(allocRequest, suballocType, vkMemReq.size, *pAllocation);

-            (*pAllocation)->InitBlockAllocation(

-                hCurrentPool,

-                pBlock,

-                allocRequest.offset,

-                vkMemReq.alignment,

-                vkMemReq.size,

-                suballocType,

-                mapped,

-                (createInfo.flags & VMA_ALLOCATION_CREATE_CAN_BECOME_LOST_BIT) != 0);

-            VMA_HEAVY_ASSERT(pBlock->Validate());

-            VMA_DEBUG_LOG("    Created new allocation Size=%llu", allocInfo.allocationSize);

-            (*pAllocation)->SetUserData(m_hAllocator, createInfo.pUserData);

-            return VK_SUCCESS;

-        }

-    }

-

-    const bool canMakeOtherLost = (createInfo.flags & VMA_ALLOCATION_CREATE_CAN_MAKE_OTHER_LOST_BIT) != 0;

-

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

-            // 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_Metadata.CreateAllocationRequest(

-                    currentFrameIndex,

-                    m_FrameInUseCount,

-                    m_BufferImageGranularity,

-                    vkMemReq.size,

-                    vkMemReq.alignment,

-                    suballocType,

-                    canMakeOtherLost,

-                    &currRequest))

-                {

-                    const VkDeviceSize currRequestCost = currRequest.CalcCost();

-                    if(pBestRequestBlock == VMA_NULL ||

-                        currRequestCost < bestRequestCost)

-                    {

-                        pBestRequestBlock = pCurrBlock;

-                        bestRequest = currRequest;

-                        bestRequestCost = currRequestCost;

-

-                        if(bestRequestCost == 0)

-                        {

-                            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_Metadata.MakeRequestedAllocationsLost(

-                    currentFrameIndex,

-                    m_FrameInUseCount,

-                    &bestRequest))

-                {

-                    // We no longer have an empty Allocation.

-                    if(pBestRequestBlock->m_Metadata.IsEmpty())

-                    {

-                        m_HasEmptyBlock = false;

-                    }

-                    // Allocate from this pBlock.

-                    *pAllocation = vma_new(m_hAllocator, VmaAllocation_T)(currentFrameIndex, isUserDataString);

-                    pBestRequestBlock->m_Metadata.Alloc(bestRequest, suballocType, vkMemReq.size, *pAllocation);

-                    (*pAllocation)->InitBlockAllocation(

-                        hCurrentPool,

-                        pBestRequestBlock,

-                        bestRequest.offset,

-                        vkMemReq.alignment,

-                        vkMemReq.size,

-                        suballocType,

-                        mapped,

-                        (createInfo.flags & VMA_ALLOCATION_CREATE_CAN_BECOME_LOST_BIT) != 0);

-                    VMA_HEAVY_ASSERT(pBestRequestBlock->Validate());

-                    VMA_DEBUG_LOG("    Returned from existing allocation #%u", (uint32_t)blockIndex);

-                    (*pAllocation)->SetUserData(m_hAllocator, createInfo.pUserData);

-                    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(

-    VmaAllocation hAllocation)

-{

-    VmaDeviceMemoryBlock* pBlockToDelete = VMA_NULL;

-

-    // Scope for lock.

-    {

-        VmaMutexLock lock(m_Mutex, m_hAllocator->m_UseMutex);

-

-        VmaDeviceMemoryBlock* pBlock = hAllocation->GetBlock();

-

-        if(hAllocation->IsPersistentMap())

-        {

-            pBlock->Unmap(m_hAllocator, 1);

-        }

-

-        pBlock->m_Metadata.Free(hAllocation);

-        VMA_HEAVY_ASSERT(pBlock->Validate());

-

-        VMA_DEBUG_LOG("  Freed from MemoryTypeIndex=%u", memTypeIndex);

-

-        // pBlock became empty after this deallocation.

-        if(pBlock->m_Metadata.IsEmpty())

-        {

-            // Already has empty Allocation. We don't want to have two, so delete this one.

-            if(m_HasEmptyBlock && m_Blocks.size() > m_MinBlockCount)

-            {

-                pBlockToDelete = pBlock;

-                Remove(pBlock);

-            }

-            // We now have first empty Allocation.

-            else

-            {

-                m_HasEmptyBlock = true;

-            }

-        }

-        // pBlock didn't become empty, but we have another empty block - find and free that one.

-        // (This is optional, heuristics.)

-        else if(m_HasEmptyBlock)

-        {

-            VmaDeviceMemoryBlock* pLastBlock = m_Blocks.back();

-            if(pLastBlock->m_Metadata.IsEmpty() && m_Blocks.size() > m_MinBlockCount)

-            {

-                pBlockToDelete = pLastBlock;

-                m_Blocks.pop_back();

-                m_HasEmptyBlock = false;

-            }

-        }

-

-        IncrementallySortBlocks();

-    }

-

-    // Destruction of a free Allocation. Deferred until this point, outside of mutex

-    // lock, for performance reason.

-    if(pBlockToDelete != VMA_NULL)

-    {

-        VMA_DEBUG_LOG("    Deleted empty allocation");

-        pBlockToDelete->Destroy(m_hAllocator);

-        vma_delete(m_hAllocator, pBlockToDelete);

-    }

-}

-

-size_t VmaBlockVector::CalcMaxBlockSize() const

-{

-    size_t result = 0;

-    for(size_t i = m_Blocks.size(); i--; )

-    {

-        result = VMA_MAX((uint64_t)result, (uint64_t)m_Blocks[i]->m_Metadata.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()

-{

-    // Bubble sort only until first swap.

-    for(size_t i = 1; i < m_Blocks.size(); ++i)

-    {

-        if(m_Blocks[i - 1]->m_Metadata.GetSumFreeSize() > m_Blocks[i]->m_Metadata.GetSumFreeSize())

-        {

-            VMA_SWAP(m_Blocks[i - 1], m_Blocks[i]);

-            return;

-        }

-    }

-}

-

-VkResult VmaBlockVector::CreateBlock(VkDeviceSize blockSize, size_t* pNewBlockIndex)

-{

-    VkMemoryAllocateInfo allocInfo = { VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_INFO };

-    allocInfo.memoryTypeIndex = m_MemoryTypeIndex;

-    allocInfo.allocationSize = blockSize;

-    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_MemoryTypeIndex,

-        mem,

-        allocInfo.allocationSize);

-

-    m_Blocks.push_back(pBlock);

-    if(pNewBlockIndex != VMA_NULL)

-    {

-        *pNewBlockIndex = m_Blocks.size() - 1;

-    }

-

-    return VK_SUCCESS;

-}

-

-#if VMA_STATS_STRING_ENABLED

-

-void VmaBlockVector::PrintDetailedMap(class VmaJsonWriter& json)

-{

-    VmaMutexLock lock(m_Mutex, m_hAllocator->m_UseMutex);

-

-    json.BeginObject();

-

-    if(m_IsCustomPool)

-    {

-        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);

-        }

-    }

-    else

-    {

-        json.WriteString("PreferredBlockSize");

-        json.WriteNumber(m_PreferredBlockSize);

-    }

-

-    json.WriteString("Blocks");

-    json.BeginArray();

-    for(size_t i = 0; i < m_Blocks.size(); ++i)

-    {

-        m_Blocks[i]->m_Metadata.PrintDetailedMap(json);

-    }

-    json.EndArray();

-

-    json.EndObject();

-}

-

-#endif // #if VMA_STATS_STRING_ENABLED

-

-VmaDefragmentator* VmaBlockVector::EnsureDefragmentator(

-    VmaAllocator hAllocator,

-    uint32_t currentFrameIndex)

-{

-    if(m_pDefragmentator == VMA_NULL)

-    {

-        m_pDefragmentator = vma_new(m_hAllocator, VmaDefragmentator)(

-            hAllocator,

-            this,

-            currentFrameIndex);

-    }

-

-    return m_pDefragmentator;

-}

-

-VkResult VmaBlockVector::Defragment(

-    VmaDefragmentationStats* pDefragmentationStats,

-    VkDeviceSize& maxBytesToMove,

-    uint32_t& maxAllocationsToMove)

-{

-    if(m_pDefragmentator == VMA_NULL)

-    {

-        return VK_SUCCESS;

-    }

-

-    VmaMutexLock lock(m_Mutex, m_hAllocator->m_UseMutex);

-

-    // Defragment.

-    VkResult result = m_pDefragmentator->Defragment(maxBytesToMove, maxAllocationsToMove);

-

-    // Accumulate statistics.

-    if(pDefragmentationStats != VMA_NULL)

-    {

-        const VkDeviceSize bytesMoved = m_pDefragmentator->GetBytesMoved();

-        const uint32_t allocationsMoved = m_pDefragmentator->GetAllocationsMoved();

-        pDefragmentationStats->bytesMoved += bytesMoved;

-        pDefragmentationStats->allocationsMoved += allocationsMoved;

-        VMA_ASSERT(bytesMoved <= maxBytesToMove);

-        VMA_ASSERT(allocationsMoved <= maxAllocationsToMove);

-        maxBytesToMove -= bytesMoved;

-        maxAllocationsToMove -= allocationsMoved;

-    }

-    

-    // Free empty blocks.

-    m_HasEmptyBlock = false;

-    for(size_t blockIndex = m_Blocks.size(); blockIndex--; )

-    {

-        VmaDeviceMemoryBlock* pBlock = m_Blocks[blockIndex];

-        if(pBlock->m_Metadata.IsEmpty())

-        {

-            if(m_Blocks.size() > m_MinBlockCount)

-            {

-                if(pDefragmentationStats != VMA_NULL)

-                {

-                    ++pDefragmentationStats->deviceMemoryBlocksFreed;

-                    pDefragmentationStats->bytesFreed += pBlock->m_Metadata.GetSize();

-                }

-

-                VmaVectorRemove(m_Blocks, blockIndex);

-                pBlock->Destroy(m_hAllocator);

-                vma_delete(m_hAllocator, pBlock);

-            }

-            else

-            {

-                m_HasEmptyBlock = true;

-            }

-        }

-    }

-

-    return result;

-}

-

-void VmaBlockVector::DestroyDefragmentator()

-{

-    if(m_pDefragmentator != VMA_NULL)

-    {

-        vma_delete(m_hAllocator, m_pDefragmentator);

-        m_pDefragmentator = VMA_NULL;

-    }

-}

-

-void VmaBlockVector::MakePoolAllocationsLost(

-    uint32_t currentFrameIndex,

-    size_t* pLostAllocationCount)

-{

-    VmaMutexLock 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_Metadata.MakeAllocationsLost(currentFrameIndex, m_FrameInUseCount);

-    }

-    if(pLostAllocationCount != VMA_NULL)

-    {

-        *pLostAllocationCount = lostAllocationCount;

-    }

-}

-

-void VmaBlockVector::AddStats(VmaStats* pStats)

-{

-    const uint32_t memTypeIndex = m_MemoryTypeIndex;

-    const uint32_t memHeapIndex = m_hAllocator->MemoryTypeIndexToHeapIndex(memTypeIndex);

-

-    VmaMutexLock 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_Metadata.CalcAllocationStatInfo(allocationStatInfo);

-        VmaAddStatInfo(pStats->total, allocationStatInfo);

-        VmaAddStatInfo(pStats->memoryType[memTypeIndex], allocationStatInfo);

-        VmaAddStatInfo(pStats->memoryHeap[memHeapIndex], allocationStatInfo);

-    }

-}

-

-////////////////////////////////////////////////////////////////////////////////

-// VmaDefragmentator members definition

-

-VmaDefragmentator::VmaDefragmentator(

-    VmaAllocator hAllocator,

-    VmaBlockVector* pBlockVector,

-    uint32_t currentFrameIndex) :

-    m_hAllocator(hAllocator),

-    m_pBlockVector(pBlockVector),

-    m_CurrentFrameIndex(currentFrameIndex),

-    m_BytesMoved(0),

-    m_AllocationsMoved(0),

-    m_Allocations(VmaStlAllocator<AllocationInfo>(hAllocator->GetAllocationCallbacks())),

-    m_Blocks(VmaStlAllocator<BlockInfo*>(hAllocator->GetAllocationCallbacks()))

-{

-}

-

-VmaDefragmentator::~VmaDefragmentator()

-{

-    for(size_t i = m_Blocks.size(); i--; )

-    {

-        vma_delete(m_hAllocator, m_Blocks[i]);

-    }

-}

-

-void VmaDefragmentator::AddAllocation(VmaAllocation hAlloc, VkBool32* pChanged)

-{

-    AllocationInfo allocInfo;

-    allocInfo.m_hAllocation = hAlloc;

-    allocInfo.m_pChanged = pChanged;

-    m_Allocations.push_back(allocInfo);

-}

-

-VkResult VmaDefragmentator::BlockInfo::EnsureMapping(VmaAllocator hAllocator, void** ppMappedData)

-{

-    // It has already been mapped for defragmentation.

-    if(m_pMappedDataForDefragmentation)

-    {

-        *ppMappedData = m_pMappedDataForDefragmentation;

-        return VK_SUCCESS;

-    }

-            

-    // It is originally mapped.

-    if(m_pBlock->GetMappedData())

-    {

-        *ppMappedData = m_pBlock->GetMappedData();

-        return VK_SUCCESS;

-    }

-            

-    // Map on first usage.

-    VkResult res = m_pBlock->Map(hAllocator, 1, &m_pMappedDataForDefragmentation);

-    *ppMappedData = m_pMappedDataForDefragmentation;

-    return res;

-}

-

-void VmaDefragmentator::BlockInfo::Unmap(VmaAllocator hAllocator)

-{

-    if(m_pMappedDataForDefragmentation != VMA_NULL)

-    {

-        m_pBlock->Unmap(hAllocator, 1);

-    }

-}

-

-VkResult VmaDefragmentator::DefragmentRound(

-    VkDeviceSize maxBytesToMove,

-    uint32_t maxAllocationsToMove)

-{

-    if(m_Blocks.empty())

-    {

-        return VK_SUCCESS;

-    }

-

-    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 - they are sorted from largest to smallest.

-        while(srcAllocIndex >= m_Blocks[srcBlockIndex]->m_Allocations.size())

-        {

-            if(m_Blocks[srcBlockIndex]->m_Allocations.empty())

-            {

-                // Finished: no more allocations to process.

-                if(srcBlockIndex == 0)

-                {

-                    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_Metadata.CreateAllocationRequest(

-                m_CurrentFrameIndex,

-                m_pBlockVector->GetFrameInUseCount(),

-                m_pBlockVector->GetBufferImageGranularity(),

-                size,

-                alignment,

-                suballocType,

-                false, // canMakeOtherLost

-                &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_INCOMPLETE;

-                }

-

-                void* pDstMappedData = VMA_NULL;

-                VkResult res = pDstBlockInfo->EnsureMapping(m_hAllocator, &pDstMappedData);

-                if(res != VK_SUCCESS)

-                {

-                    return res;

-                }

-

-                void* pSrcMappedData = VMA_NULL;

-                res = pSrcBlockInfo->EnsureMapping(m_hAllocator, &pSrcMappedData);

-                if(res != VK_SUCCESS)

-                {

-                    return res;

-                }

-                

-                // THE PLACE WHERE ACTUAL DATA COPY HAPPENS.

-                memcpy(

-                    reinterpret_cast<char*>(pDstMappedData) + dstAllocRequest.offset,

-                    reinterpret_cast<char*>(pSrcMappedData) + srcOffset,

-                    static_cast<size_t>(size));

-                

-                pDstBlockInfo->m_pBlock->m_Metadata.Alloc(dstAllocRequest, suballocType, size, allocInfo.m_hAllocation);

-                pSrcBlockInfo->m_pBlock->m_Metadata.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;

-            }

-        }

-    }

-}

-

-VkResult VmaDefragmentator::Defragment(

-    VkDeviceSize maxBytesToMove,

-    uint32_t maxAllocationsToMove)

-{

-    if(m_Allocations.empty())

-    {

-        return VK_SUCCESS;

-    }

-

-    // 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_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());

-

-    // Move allocation infos from m_Allocations to appropriate m_Blocks[memTypeIndex].m_Allocations.

-    for(size_t blockIndex = 0, allocCount = m_Allocations.size(); blockIndex < allocCount; ++blockIndex)

-    {

-        AllocationInfo& allocInfo = m_Allocations[blockIndex];

-        // Now as we are inside VmaBlockVector::m_Mutex, we can make final check if this allocation was not lost.

-        if(allocInfo.m_hAllocation->GetLastUseFrameIndex() != VMA_FRAME_INDEX_LOST)

-        {

-            VmaDeviceMemoryBlock* pBlock = allocInfo.m_hAllocation->GetBlock();

-            BlockInfoVector::iterator it = VmaBinaryFindFirstNotLess(m_Blocks.begin(), m_Blocks.end(), pBlock, BlockPointerLess());

-            if(it != m_Blocks.end() && (*it)->m_pBlock == pBlock)

-            {

-                (*it)->m_Allocations.push_back(allocInfo);

-            }

-            else

-            {

-                VMA_ASSERT(0);

-            }

-        }

-    }

-    m_Allocations.clear();

-

-    for(size_t blockIndex = 0; blockIndex < blockCount; ++blockIndex)

-    {

-        BlockInfo* pBlockInfo = m_Blocks[blockIndex];

-        pBlockInfo->CalcHasNonMovableAllocations();

-        pBlockInfo->SortAllocationsBySizeDescecnding();

-    }

-

-    // 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());

-

-    // Execute defragmentation rounds (the main part).

-    VkResult result = VK_SUCCESS;

-    for(size_t round = 0; (round < 2) && (result == VK_SUCCESS); ++round)

-    {

-        result = DefragmentRound(maxBytesToMove, maxAllocationsToMove);

-    }

-

-    // Unmap blocks that were mapped for defragmentation.

-    for(size_t blockIndex = 0; blockIndex < blockCount; ++blockIndex)

-    {

-        m_Blocks[blockIndex]->Unmap(m_hAllocator);

-    }

-

-    return result;

-}

-

-bool VmaDefragmentator::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;

-}

-

-////////////////////////////////////////////////////////////////////////////////

-// VmaAllocator_T

-

-VmaAllocator_T::VmaAllocator_T(const VmaAllocatorCreateInfo* pCreateInfo) :

-    m_UseMutex((pCreateInfo->flags & VMA_ALLOCATOR_CREATE_EXTERNALLY_SYNCHRONIZED_BIT) == 0),

-    m_UseKhrDedicatedAllocation((pCreateInfo->flags & VMA_ALLOCATOR_CREATE_KHR_DEDICATED_ALLOCATION_BIT) != 0),

-    m_hDevice(pCreateInfo->device),

-    m_AllocationCallbacksSpecified(pCreateInfo->pAllocationCallbacks != VMA_NULL),

-    m_AllocationCallbacks(pCreateInfo->pAllocationCallbacks ?

-        *pCreateInfo->pAllocationCallbacks : VmaEmptyAllocationCallbacks),

-    m_PreferredLargeHeapBlockSize(0),

-    m_PhysicalDevice(pCreateInfo->physicalDevice),

-    m_CurrentFrameIndex(0),

-    m_Pools(VmaStlAllocator<VmaPool>(GetAllocationCallbacks()))

-{

-    VMA_ASSERT(pCreateInfo->physicalDevice && pCreateInfo->device);    

-

-    memset(&m_DeviceMemoryCallbacks, 0 ,sizeof(m_DeviceMemoryCallbacks));

-    memset(&m_MemProps, 0, sizeof(m_MemProps));

-    memset(&m_PhysicalDeviceProperties, 0, sizeof(m_PhysicalDeviceProperties));

-        

-    memset(&m_pBlockVectors, 0, sizeof(m_pBlockVectors));

-    memset(&m_pDedicatedAllocations, 0, sizeof(m_pDedicatedAllocations));

-

-    for(uint32_t i = 0; i < VK_MAX_MEMORY_HEAPS; ++i)

-    {

-        m_HeapSizeLimit[i] = VK_WHOLE_SIZE;

-    }

-

-    if(pCreateInfo->pDeviceMemoryCallbacks != VMA_NULL)

-    {

-        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);

-

-    m_PreferredLargeHeapBlockSize = (pCreateInfo->preferredLargeHeapBlockSize != 0) ?

-        pCreateInfo->preferredLargeHeapBlockSize : static_cast<VkDeviceSize>(VMA_DEFAULT_LARGE_HEAP_BLOCK_SIZE);

-

-    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_HeapSizeLimit[heapIndex] = limit;

-                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,

-            memTypeIndex,

-            preferredBlockSize,

-            0,

-            SIZE_MAX,

-            GetBufferImageGranularity(),

-            pCreateInfo->frameInUseCount,

-            false); // isCustomPool

-        // No need to call m_pBlockVectors[memTypeIndex][blockVectorTypeIndex]->CreateMinBlocks here,

-        // becase minBlockCount is 0.

-        m_pDedicatedAllocations[memTypeIndex] = vma_new(this, AllocationVectorType)(VmaStlAllocator<VmaAllocation>(GetAllocationCallbacks()));

-    }

-}

-

-VmaAllocator_T::~VmaAllocator_T()

-{

-    VMA_ASSERT(m_Pools.empty());

-

-    for(size_t i = GetMemoryTypeCount(); i--; )

-    {

-        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

-    m_VulkanFunctions.vkGetPhysicalDeviceProperties = &vkGetPhysicalDeviceProperties;

-    m_VulkanFunctions.vkGetPhysicalDeviceMemoryProperties = &vkGetPhysicalDeviceMemoryProperties;

-    m_VulkanFunctions.vkAllocateMemory = &vkAllocateMemory;

-    m_VulkanFunctions.vkFreeMemory = &vkFreeMemory;

-    m_VulkanFunctions.vkMapMemory = &vkMapMemory;

-    m_VulkanFunctions.vkUnmapMemory = &vkUnmapMemory;

-    m_VulkanFunctions.vkBindBufferMemory = &vkBindBufferMemory;

-    m_VulkanFunctions.vkBindImageMemory = &vkBindImageMemory;

-    m_VulkanFunctions.vkGetBufferMemoryRequirements = &vkGetBufferMemoryRequirements;

-    m_VulkanFunctions.vkGetImageMemoryRequirements = &vkGetImageMemoryRequirements;

-    m_VulkanFunctions.vkCreateBuffer = &vkCreateBuffer;

-    m_VulkanFunctions.vkDestroyBuffer = &vkDestroyBuffer;

-    m_VulkanFunctions.vkCreateImage = &vkCreateImage;

-    m_VulkanFunctions.vkDestroyImage = &vkDestroyImage;

-    if(m_UseKhrDedicatedAllocation)

-    {

-        m_VulkanFunctions.vkGetBufferMemoryRequirements2KHR =

-            (PFN_vkGetBufferMemoryRequirements2KHR)vkGetDeviceProcAddr(m_hDevice, "vkGetBufferMemoryRequirements2KHR");

-        m_VulkanFunctions.vkGetImageMemoryRequirements2KHR =

-            (PFN_vkGetImageMemoryRequirements2KHR)vkGetDeviceProcAddr(m_hDevice, "vkGetImageMemoryRequirements2KHR");

-    }

-#endif // #if VMA_STATIC_VULKAN_FUNCTIONS == 1

-

-#define VMA_COPY_IF_NOT_NULL(funcName) \

-    if(pVulkanFunctions->funcName != VMA_NULL) m_VulkanFunctions.funcName = pVulkanFunctions->funcName;

-

-    if(pVulkanFunctions != VMA_NULL)

-    {

-        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(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(vkGetBufferMemoryRequirements2KHR);

-        VMA_COPY_IF_NOT_NULL(vkGetImageMemoryRequirements2KHR);

-    }

-

-#undef VMA_COPY_IF_NOT_NULL

-

-    // If these asserts are hit, you must either #define VMA_STATIC_VULKAN_FUNCTIONS 1

-    // or pass valid pointers as VmaAllocatorCreateInfo::pVulkanFunctions.

-    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.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);

-    if(m_UseKhrDedicatedAllocation)

-    {

-        VMA_ASSERT(m_VulkanFunctions.vkGetBufferMemoryRequirements2KHR != VMA_NULL);

-        VMA_ASSERT(m_VulkanFunctions.vkGetImageMemoryRequirements2KHR != VMA_NULL);

-    }

-}

-

-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 isSmallHeap ? (heapSize / 8) : m_PreferredLargeHeapBlockSize;

-}

-

-VkResult VmaAllocator_T::AllocateMemoryOfType(

-    const VkMemoryRequirements& vkMemReq,

-    bool dedicatedAllocation,

-    VkBuffer dedicatedBuffer,

-    VkImage dedicatedImage,

-    const VmaAllocationCreateInfo& createInfo,

-    uint32_t memTypeIndex,

-    VmaSuballocationType suballocType,

-    VmaAllocation* pAllocation)

-{

-    VMA_ASSERT(pAllocation != VMA_NULL);

-    VMA_DEBUG_LOG("  AllocateMemory: MemoryTypeIndex=%u, Size=%llu", memTypeIndex, vkMemReq.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;

-    }

-

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

-        vkMemReq.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(

-                vkMemReq.size,

-                suballocType,

-                memTypeIndex,

-                (finalCreateInfo.flags & VMA_ALLOCATION_CREATE_MAPPED_BIT) != 0,

-                (finalCreateInfo.flags & VMA_ALLOCATION_CREATE_USER_DATA_COPY_STRING_BIT) != 0,

-                finalCreateInfo.pUserData,

-                dedicatedBuffer,

-                dedicatedImage,

-                pAllocation);

-        }

-    }

-    else

-    {

-        VkResult res = blockVector->Allocate(

-            VK_NULL_HANDLE, // hCurrentPool

-            m_CurrentFrameIndex.load(),

-            vkMemReq,

-            finalCreateInfo,

-            suballocType,

-            pAllocation);

-        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(

-                vkMemReq.size,

-                suballocType,

-                memTypeIndex,

-                (finalCreateInfo.flags & VMA_ALLOCATION_CREATE_MAPPED_BIT) != 0,

-                (finalCreateInfo.flags & VMA_ALLOCATION_CREATE_USER_DATA_COPY_STRING_BIT) != 0,

-                finalCreateInfo.pUserData,

-                dedicatedBuffer,

-                dedicatedImage,

-                pAllocation);

-            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 map,

-    bool isUserDataString,

-    void* pUserData,

-    VkBuffer dedicatedBuffer,

-    VkImage dedicatedImage,

-    VmaAllocation* pAllocation)

-{

-    VMA_ASSERT(pAllocation);

-

-    VkMemoryAllocateInfo allocInfo = { VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_INFO };

-    allocInfo.memoryTypeIndex = memTypeIndex;

-    allocInfo.allocationSize = size;

-

-    VkMemoryDedicatedAllocateInfoKHR dedicatedAllocInfo = { VK_STRUCTURE_TYPE_MEMORY_DEDICATED_ALLOCATE_INFO_KHR };

-    if(m_UseKhrDedicatedAllocation)

-    {

-        if(dedicatedBuffer != VK_NULL_HANDLE)

-        {

-            VMA_ASSERT(dedicatedImage == VK_NULL_HANDLE);

-            dedicatedAllocInfo.buffer = dedicatedBuffer;

-            allocInfo.pNext = &dedicatedAllocInfo;

-        }

-        else if(dedicatedImage != VK_NULL_HANDLE)

-        {

-            dedicatedAllocInfo.image = dedicatedImage;

-            allocInfo.pNext = &dedicatedAllocInfo;

-        }

-    }

-

-    // Allocate VkDeviceMemory.

-    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 = vma_new(this, VmaAllocation_T)(m_CurrentFrameIndex.load(), isUserDataString);

-    (*pAllocation)->InitDedicatedAllocation(memTypeIndex, hMemory, suballocType, pMappedData, size);

-    (*pAllocation)->SetUserData(this, pUserData);

-

-    // Register it in m_pDedicatedAllocations.

-    {

-        VmaMutexLock lock(m_DedicatedAllocationsMutex[memTypeIndex], m_UseMutex);

-        AllocationVectorType* pDedicatedAllocations = m_pDedicatedAllocations[memTypeIndex];

-        VMA_ASSERT(pDedicatedAllocations);

-        VmaVectorInsertSorted<VmaPointerLess>(*pDedicatedAllocations, *pAllocation);

-    }

-

-    VMA_DEBUG_LOG("    Allocated DedicatedMemory MemoryTypeIndex=#%u", memTypeIndex);

-

-    return VK_SUCCESS;

-}

-

-void VmaAllocator_T::GetBufferMemoryRequirements(

-    VkBuffer hBuffer,

-    VkMemoryRequirements& memReq,

-    bool& requiresDedicatedAllocation,

-    bool& prefersDedicatedAllocation) const

-{

-    if(m_UseKhrDedicatedAllocation)

-    {

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

-        memReq2.pNext = &memDedicatedReq;

-

-        (*m_VulkanFunctions.vkGetBufferMemoryRequirements2KHR)(m_hDevice, &memReqInfo, &memReq2);

-

-        memReq = memReq2.memoryRequirements;

-        requiresDedicatedAllocation = (memDedicatedReq.requiresDedicatedAllocation != VK_FALSE);

-        prefersDedicatedAllocation  = (memDedicatedReq.prefersDedicatedAllocation  != VK_FALSE);

-    }

-    else

-    {

-        (*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(m_UseKhrDedicatedAllocation)

-    {

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

-        memReq2.pNext = &memDedicatedReq;

-

-        (*m_VulkanFunctions.vkGetImageMemoryRequirements2KHR)(m_hDevice, &memReqInfo, &memReq2);

-

-        memReq = memReq2.memoryRequirements;

-        requiresDedicatedAllocation = (memDedicatedReq.requiresDedicatedAllocation != VK_FALSE);

-        prefersDedicatedAllocation  = (memDedicatedReq.prefersDedicatedAllocation  != VK_FALSE);

-    }

-    else

-    {

-        (*m_VulkanFunctions.vkGetImageMemoryRequirements)(m_hDevice, hImage, &memReq);

-        requiresDedicatedAllocation = false;

-        prefersDedicatedAllocation  = false;

-    }

-}

-

-VkResult VmaAllocator_T::AllocateMemory(

-    const VkMemoryRequirements& vkMemReq,

-    bool requiresDedicatedAllocation,

-    bool prefersDedicatedAllocation,

-    VkBuffer dedicatedBuffer,

-    VkImage dedicatedImage,

-    const VmaAllocationCreateInfo& createInfo,

-    VmaSuballocationType suballocType,

-    VmaAllocation* pAllocation)

-{

-    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)

-    {

-        return createInfo.pool->m_BlockVector.Allocate(

-            createInfo.pool,

-            m_CurrentFrameIndex.load(),

-            vkMemReq,

-            createInfo,

-            suballocType,

-            pAllocation);

-    }

-    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)

-        {

-            res = AllocateMemoryOfType(

-                vkMemReq,

-                requiresDedicatedAllocation || prefersDedicatedAllocation,

-                dedicatedBuffer,

-                dedicatedImage,

-                createInfo,

-                memTypeIndex,

-                suballocType,

-                pAllocation);

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

-                    {

-                        res = AllocateMemoryOfType(

-                            vkMemReq,

-                            requiresDedicatedAllocation || prefersDedicatedAllocation,

-                            dedicatedBuffer,

-                            dedicatedImage,

-                            createInfo,

-                            memTypeIndex,

-                            suballocType,

-                            pAllocation);

-                        // 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(const VmaAllocation allocation)

-{

-    VMA_ASSERT(allocation);

-

-    if(allocation->CanBecomeLost() == false ||

-        allocation->GetLastUseFrameIndex() != VMA_FRAME_INDEX_LOST)

-    {

-        switch(allocation->GetType())

-        {

-        case VmaAllocation_T::ALLOCATION_TYPE_BLOCK:

-            {

-                VmaBlockVector* pBlockVector = VMA_NULL;

-                VmaPool hPool = allocation->GetPool();

-                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);

-        }

-    }

-

-    allocation->SetUserData(this, VMA_NULL);

-    vma_delete(this, allocation);

-}

-

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

-    {

-        VmaMutexLock lock(m_PoolsMutex, m_UseMutex);

-        for(size_t poolIndex = 0, poolCount = m_Pools.size(); poolIndex < poolCount; ++poolIndex)

-        {

-            m_Pools[poolIndex]->GetBlockVector().AddStats(pStats);

-        }

-    }

-

-    // Process dedicated allocations.

-    for(uint32_t memTypeIndex = 0; memTypeIndex < GetMemoryTypeCount(); ++memTypeIndex)

-    {

-        const uint32_t memHeapIndex = MemoryTypeIndexToHeapIndex(memTypeIndex);

-        VmaMutexLock 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]);

-}

-

-static const uint32_t VMA_VENDOR_ID_AMD = 4098;

-

-VkResult VmaAllocator_T::Defragment(

-    VmaAllocation* pAllocations,

-    size_t allocationCount,

-    VkBool32* pAllocationsChanged,

-    const VmaDefragmentationInfo* pDefragmentationInfo,

-    VmaDefragmentationStats* pDefragmentationStats)

-{

-    if(pAllocationsChanged != VMA_NULL)

-    {

-        memset(pAllocationsChanged, 0, sizeof(*pAllocationsChanged));

-    }

-    if(pDefragmentationStats != VMA_NULL)

-    {

-        memset(pDefragmentationStats, 0, sizeof(*pDefragmentationStats));

-    }

-

-    const uint32_t currentFrameIndex = m_CurrentFrameIndex.load();

-

-    VmaMutexLock poolsLock(m_PoolsMutex, m_UseMutex);

-

-    const size_t poolCount = m_Pools.size();

-

-    // Dispatch pAllocations among defragmentators. Create them in BlockVectors when necessary.

-    for(size_t allocIndex = 0; allocIndex < allocationCount; ++allocIndex)

-    {

-        VmaAllocation hAlloc = pAllocations[allocIndex];

-        VMA_ASSERT(hAlloc);

-        const uint32_t memTypeIndex = hAlloc->GetMemoryTypeIndex();

-        // DedicatedAlloc cannot be defragmented.

-        if((hAlloc->GetType() == VmaAllocation_T::ALLOCATION_TYPE_BLOCK) &&

-            // Only HOST_VISIBLE memory types can be defragmented.

-            ((m_MemProps.memoryTypes[memTypeIndex].propertyFlags & VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT) != 0) &&

-            // Lost allocation cannot be defragmented.

-            (hAlloc->GetLastUseFrameIndex() != VMA_FRAME_INDEX_LOST))

-        {

-            VmaBlockVector* pAllocBlockVector = VMA_NULL;

-

-            const VmaPool hAllocPool = hAlloc->GetPool();

-            // This allocation belongs to custom pool.

-            if(hAllocPool != VK_NULL_HANDLE)

-            {

-                pAllocBlockVector = &hAllocPool->GetBlockVector();

-            }

-            // This allocation belongs to general pool.

-            else

-            {

-                pAllocBlockVector = m_pBlockVectors[memTypeIndex];

-            }

-

-            VmaDefragmentator* const pDefragmentator = pAllocBlockVector->EnsureDefragmentator(this, currentFrameIndex);

-

-            VkBool32* const pChanged = (pAllocationsChanged != VMA_NULL) ?

-                &pAllocationsChanged[allocIndex] : VMA_NULL;

-            pDefragmentator->AddAllocation(hAlloc, pChanged);

-        }

-    }

-

-    VkResult result = VK_SUCCESS;

-

-    // ======== Main processing.

-

-    VkDeviceSize maxBytesToMove = SIZE_MAX;

-    uint32_t maxAllocationsToMove = UINT32_MAX;

-    if(pDefragmentationInfo != VMA_NULL)

-    {

-        maxBytesToMove = pDefragmentationInfo->maxBytesToMove;

-        maxAllocationsToMove = pDefragmentationInfo->maxAllocationsToMove;

-    }

-

-    // Process standard memory.

-    for(uint32_t memTypeIndex = 0;

-        (memTypeIndex < GetMemoryTypeCount()) && (result == VK_SUCCESS);

-        ++memTypeIndex)

-    {

-        // Only HOST_VISIBLE memory types can be defragmented.

-        if((m_MemProps.memoryTypes[memTypeIndex].propertyFlags & VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT) != 0)

-        {

-            result = m_pBlockVectors[memTypeIndex]->Defragment(

-                pDefragmentationStats,

-                maxBytesToMove,

-                maxAllocationsToMove);

-        }

-    }

-

-    // Process custom pools.

-    for(size_t poolIndex = 0; (poolIndex < poolCount) && (result == VK_SUCCESS); ++poolIndex)

-    {

-        result = m_Pools[poolIndex]->GetBlockVector().Defragment(

-            pDefragmentationStats,

-            maxBytesToMove,

-            maxAllocationsToMove);

-    }

-

-    // ========  Destroy defragmentators.

-

-    // Process custom pools.

-    for(size_t poolIndex = poolCount; poolIndex--; )

-    {

-        m_Pools[poolIndex]->GetBlockVector().DestroyDefragmentator();

-    }

-

-    // Process standard memory.

-    for(uint32_t memTypeIndex = GetMemoryTypeCount(); memTypeIndex--; )

-    {

-        if((m_MemProps.memoryTypes[memTypeIndex].propertyFlags & VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT) != 0)

-        {

-            m_pBlockVectors[memTypeIndex]->DestroyDefragmentator();

-        }

-    }

-

-    return result;

-}

-

-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 :)

-        */

-        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

-    {

-        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

-    {

-        return true;

-    }

-}

-

-VkResult VmaAllocator_T::CreatePool(const VmaPoolCreateInfo* pCreateInfo, VmaPool* pPool)

-{

-    VMA_DEBUG_LOG("  CreatePool: MemoryTypeIndex=%u", pCreateInfo->memoryTypeIndex);

-

-    VmaPoolCreateInfo newCreateInfo = *pCreateInfo;

-

-    if(newCreateInfo.maxBlockCount == 0)

-    {

-        newCreateInfo.maxBlockCount = SIZE_MAX;

-    }

-    if(newCreateInfo.blockSize == 0)

-    {

-        newCreateInfo.blockSize = CalcPreferredBlockSize(newCreateInfo.memoryTypeIndex);

-    }

-

-    *pPool = vma_new(this, VmaPool_T)(this, newCreateInfo);

-

-    VkResult res = (*pPool)->m_BlockVector.CreateMinBlocks();

-    if(res != VK_SUCCESS)

-    {

-        vma_delete(this, *pPool);

-        *pPool = VMA_NULL;

-        return res;

-    }

-

-    // Add to m_Pools.

-    {

-        VmaMutexLock lock(m_PoolsMutex, m_UseMutex);

-        VmaVectorInsertSorted<VmaPointerLess>(m_Pools, *pPool);

-    }

-

-    return VK_SUCCESS;

-}

-

-void VmaAllocator_T::DestroyPool(VmaPool pool)

-{

-    // Remove from m_Pools.

-    {

-        VmaMutexLock 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);

-}

-

-void VmaAllocator_T::MakePoolAllocationsLost(

-    VmaPool hPool,

-    size_t* pLostAllocationCount)

-{

-    hPool->m_BlockVector.MakePoolAllocationsLost(

-        m_CurrentFrameIndex.load(),

-        pLostAllocationCount);

-}

-

-void VmaAllocator_T::CreateLostAllocation(VmaAllocation* pAllocation)

-{

-    *pAllocation = vma_new(this, VmaAllocation_T)(VMA_FRAME_INDEX_LOST, false);

-    (*pAllocation)->InitLost();

-}

-

-VkResult VmaAllocator_T::AllocateVulkanMemory(const VkMemoryAllocateInfo* pAllocateInfo, VkDeviceMemory* pMemory)

-{

-    const uint32_t heapIndex = MemoryTypeIndexToHeapIndex(pAllocateInfo->memoryTypeIndex);

-

-    VkResult res;

-    if(m_HeapSizeLimit[heapIndex] != VK_WHOLE_SIZE)

-    {

-        VmaMutexLock lock(m_HeapSizeLimitMutex, m_UseMutex);

-        if(m_HeapSizeLimit[heapIndex] >= pAllocateInfo->allocationSize)

-        {

-            res = (*m_VulkanFunctions.vkAllocateMemory)(m_hDevice, pAllocateInfo, GetAllocationCallbacks(), pMemory);

-            if(res == VK_SUCCESS)

-            {

-                m_HeapSizeLimit[heapIndex] -= pAllocateInfo->allocationSize;

-            }

-        }

-        else

-        {

-            res = VK_ERROR_OUT_OF_DEVICE_MEMORY;

-        }

-    }

-    else

-    {

-        res = (*m_VulkanFunctions.vkAllocateMemory)(m_hDevice, pAllocateInfo, GetAllocationCallbacks(), pMemory);

-    }

-

-    if(res == VK_SUCCESS && m_DeviceMemoryCallbacks.pfnAllocate != VMA_NULL)

-    {

-        (*m_DeviceMemoryCallbacks.pfnAllocate)(this, pAllocateInfo->memoryTypeIndex, *pMemory, pAllocateInfo->allocationSize);

-    }

-

-    return res;

-}

-

-void VmaAllocator_T::FreeVulkanMemory(uint32_t memoryType, VkDeviceSize size, VkDeviceMemory hMemory)

-{

-    if(m_DeviceMemoryCallbacks.pfnFree != VMA_NULL)

-    {

-        (*m_DeviceMemoryCallbacks.pfnFree)(this, memoryType, hMemory, size);

-    }

-

-    (*m_VulkanFunctions.vkFreeMemory)(m_hDevice, hMemory, GetAllocationCallbacks());

-

-    const uint32_t heapIndex = MemoryTypeIndexToHeapIndex(memoryType);

-    if(m_HeapSizeLimit[heapIndex] != VK_WHOLE_SIZE)

-    {

-        VmaMutexLock lock(m_HeapSizeLimitMutex, m_UseMutex);

-        m_HeapSizeLimit[heapIndex] += size;

-    }

-}

-

-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, VkBuffer hBuffer)

-{

-    VkResult res = VK_SUCCESS;

-    switch(hAllocation->GetType())

-    {

-    case VmaAllocation_T::ALLOCATION_TYPE_DEDICATED:

-        res = GetVulkanFunctions().vkBindBufferMemory(

-            m_hDevice,

-            hBuffer,

-            hAllocation->GetMemory(),

-            0); //memoryOffset

-        break;

-    case VmaAllocation_T::ALLOCATION_TYPE_BLOCK:

-    {

-        VmaDeviceMemoryBlock* 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, hBuffer);

-        break;

-    }

-    default:

-        VMA_ASSERT(0);

-    }

-    return res;

-}

-

-VkResult VmaAllocator_T::BindImageMemory(VmaAllocation hAllocation, VkImage hImage)

-{

-    VkResult res = VK_SUCCESS;

-    switch(hAllocation->GetType())

-    {

-    case VmaAllocation_T::ALLOCATION_TYPE_DEDICATED:

-        res = GetVulkanFunctions().vkBindImageMemory(

-            m_hDevice,

-            hImage,

-            hAllocation->GetMemory(),

-            0); //memoryOffset

-        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, hImage);

-        break;

-    }

-    default:

-        VMA_ASSERT(0);

-    }

-    return res;

-}

-

-void VmaAllocator_T::FreeDedicatedMemory(VmaAllocation allocation)

-{

-    VMA_ASSERT(allocation && allocation->GetType() == VmaAllocation_T::ALLOCATION_TYPE_DEDICATED);

-

-    const uint32_t memTypeIndex = allocation->GetMemoryTypeIndex();

-    {

-        VmaMutexLock 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();

-    

-    if(allocation->GetMappedData() != VMA_NULL)

-    {

-        (*m_VulkanFunctions.vkUnmapMemory)(m_hDevice, hMemory);

-    }

-    

-    FreeVulkanMemory(memTypeIndex, allocation->GetSize(), hMemory);

-

-    VMA_DEBUG_LOG("    Freed DedicatedMemory MemoryTypeIndex=%u", memTypeIndex);

-}

-

-#if VMA_STATS_STRING_ENABLED

-

-void VmaAllocator_T::PrintDetailedMap(VmaJsonWriter& json)

-{

-    bool dedicatedAllocationsStarted = false;

-    for(uint32_t memTypeIndex = 0; memTypeIndex < GetMemoryTypeCount(); ++memTypeIndex)

-    {

-        VmaMutexLock 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)

-            {

-                const VmaAllocation hAlloc = (*pDedicatedAllocVector)[i];

-                json.BeginObject(true);

-                    

-                json.WriteString("Type");

-                json.WriteString(VMA_SUBALLOCATION_TYPE_NAMES[hAlloc->GetSuballocationType()]);

-

-                json.WriteString("Size");

-                json.WriteNumber(hAlloc->GetSize());

-

-                const void* pUserData = hAlloc->GetUserData();

-                if(pUserData != VMA_NULL)

-                {

-                    json.WriteString("UserData");

-                    if(hAlloc->IsUserDataString())

-                    {

-                        json.WriteString((const char*)pUserData);

-                    }

-                    else

-                    {

-                        json.BeginString();

-                        json.ContinueString_Pointer(pUserData);

-                        json.EndString();

-                    }

-                }

-

-                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();

-        }

-    }

-

-    {

-        VmaMutexLock lock(m_PoolsMutex, m_UseMutex);

-        const size_t poolCount = m_Pools.size();

-        if(poolCount > 0)

-        {

-            json.WriteString("Pools");

-            json.BeginArray();

-            for(size_t poolIndex = 0; poolIndex < poolCount; ++poolIndex)

-            {

-                m_Pools[poolIndex]->m_BlockVector.PrintDetailedMap(json);

-            }

-            json.EndArray();

-        }

-    }

-}

-

-#endif // #if VMA_STATS_STRING_ENABLED

-

-static VkResult AllocateMemoryForImage(

-    VmaAllocator allocator,

-    VkImage image,

-    const VmaAllocationCreateInfo* pAllocationCreateInfo,

-    VmaSuballocationType suballocType,

-    VmaAllocation* pAllocation)

-{

-    VMA_ASSERT(allocator && (image != VK_NULL_HANDLE) && pAllocationCreateInfo && pAllocation);

-    

-    VkMemoryRequirements vkMemReq = {};

-    bool requiresDedicatedAllocation = false;

-    bool prefersDedicatedAllocation  = false;

-    allocator->GetImageMemoryRequirements(image, vkMemReq,

-        requiresDedicatedAllocation, prefersDedicatedAllocation);

-

-    return allocator->AllocateMemory(

-        vkMemReq,

-        requiresDedicatedAllocation,

-        prefersDedicatedAllocation,

-        VK_NULL_HANDLE, // dedicatedBuffer

-        image, // dedicatedImage

-        *pAllocationCreateInfo,

-        suballocType,

-        pAllocation);

-}

-

-////////////////////////////////////////////////////////////////////////////////

-// Public interface

-

-VkResult vmaCreateAllocator(

-    const VmaAllocatorCreateInfo* pCreateInfo,

-    VmaAllocator* pAllocator)

-{

-    VMA_ASSERT(pCreateInfo && pAllocator);

-    VMA_DEBUG_LOG("vmaCreateAllocator");

-    *pAllocator = vma_new(pCreateInfo->pAllocationCallbacks, VmaAllocator_T)(pCreateInfo);

-    return VK_SUCCESS;

-}

-

-void vmaDestroyAllocator(

-    VmaAllocator allocator)

-{

-    if(allocator != VK_NULL_HANDLE)

-    {

-        VMA_DEBUG_LOG("vmaDestroyAllocator");

-        VkAllocationCallbacks allocationCallbacks = allocator->m_AllocationCallbacks;

-        vma_delete(&allocationCallbacks, allocator);

-    }

-}

-

-void vmaGetPhysicalDeviceProperties(

-    VmaAllocator allocator,

-    const VkPhysicalDeviceProperties **ppPhysicalDeviceProperties)

-{

-    VMA_ASSERT(allocator && ppPhysicalDeviceProperties);

-    *ppPhysicalDeviceProperties = &allocator->m_PhysicalDeviceProperties;

-}

-

-void vmaGetMemoryProperties(

-    VmaAllocator allocator,

-    const VkPhysicalDeviceMemoryProperties** ppPhysicalDeviceMemoryProperties)

-{

-    VMA_ASSERT(allocator && ppPhysicalDeviceMemoryProperties);

-    *ppPhysicalDeviceMemoryProperties = &allocator->m_MemProps;

-}

-

-void vmaGetMemoryTypeProperties(

-    VmaAllocator allocator,

-    uint32_t memoryTypeIndex,

-    VkMemoryPropertyFlags* pFlags)

-{

-    VMA_ASSERT(allocator && pFlags);

-    VMA_ASSERT(memoryTypeIndex < allocator->GetMemoryTypeCount());

-    *pFlags = allocator->m_MemProps.memoryTypes[memoryTypeIndex].propertyFlags;

-}

-

-void vmaSetCurrentFrameIndex(

-    VmaAllocator allocator,

-    uint32_t frameIndex)

-{

-    VMA_ASSERT(allocator);

-    VMA_ASSERT(frameIndex != VMA_FRAME_INDEX_LOST);

-

-    VMA_DEBUG_GLOBAL_MUTEX_LOCK

-

-    allocator->SetCurrentFrameIndex(frameIndex);

-}

-

-void vmaCalculateStats(

-    VmaAllocator allocator,

-    VmaStats* pStats)

-{

-    VMA_ASSERT(allocator && pStats);

-    VMA_DEBUG_GLOBAL_MUTEX_LOCK

-    allocator->CalculateStats(pStats);

-}

-

-#if VMA_STATS_STRING_ENABLED

-

-void 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();

-

-        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();

-

-            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");

-                    }

-                    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;

-}

-

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

-*/

-VkResult 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);

-

-    if(pAllocationCreateInfo->memoryTypeBits != 0)

-    {

-        memoryTypeBits &= pAllocationCreateInfo->memoryTypeBits;

-    }

-    

-    uint32_t requiredFlags = pAllocationCreateInfo->requiredFlags;

-    uint32_t preferredFlags = pAllocationCreateInfo->preferredFlags;

-

-    // Convert usage to requiredFlags and preferredFlags.

-    switch(pAllocationCreateInfo->usage)

-    {

-    case VMA_MEMORY_USAGE_UNKNOWN:

-        break;

-    case VMA_MEMORY_USAGE_GPU_ONLY:

-        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;

-        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_COHERENT_BIT | VK_MEMORY_PROPERTY_HOST_CACHED_BIT;

-        break;

-    default:

-        break;

-    }

-

-    *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);

-                // Remember memory type with lowest cost.

-                if(currCost < minCost)

-                {

-                    *pMemoryTypeIndex = memTypeIndex;

-                    if(currCost == 0)

-                    {

-                        return VK_SUCCESS;

-                    }

-                    minCost = currCost;

-                }

-            }

-        }

-    }

-    return (*pMemoryTypeIndex != UINT32_MAX) ? VK_SUCCESS : VK_ERROR_FEATURE_NOT_PRESENT;

-}

-

-VkResult 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;

-}

-

-VkResult 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;

-}

-

-VkResult vmaCreatePool(

-	VmaAllocator allocator,

-	const VmaPoolCreateInfo* pCreateInfo,

-	VmaPool* pPool)

-{

-    VMA_ASSERT(allocator && pCreateInfo && pPool);

-

-    VMA_DEBUG_LOG("vmaCreatePool");

-

-    VMA_DEBUG_GLOBAL_MUTEX_LOCK

-

-    return allocator->CreatePool(pCreateInfo, pPool);

-}

-

-void vmaDestroyPool(

-    VmaAllocator allocator,

-    VmaPool pool)

-{

-    VMA_ASSERT(allocator);

-

-    if(pool == VK_NULL_HANDLE)

-    {

-        return;

-    }

-

-    VMA_DEBUG_LOG("vmaDestroyPool");

-

-    VMA_DEBUG_GLOBAL_MUTEX_LOCK

-

-    allocator->DestroyPool(pool);

-}

-

-void vmaGetPoolStats(

-    VmaAllocator allocator,

-    VmaPool pool,

-    VmaPoolStats* pPoolStats)

-{

-    VMA_ASSERT(allocator && pool && pPoolStats);

-

-    VMA_DEBUG_GLOBAL_MUTEX_LOCK

-

-    allocator->GetPoolStats(pool, pPoolStats);

-}

-

-void vmaMakePoolAllocationsLost(

-    VmaAllocator allocator,

-    VmaPool pool,

-    size_t* pLostAllocationCount)

-{

-    VMA_ASSERT(allocator && pool);

-

-    VMA_DEBUG_GLOBAL_MUTEX_LOCK

-

-    allocator->MakePoolAllocationsLost(pool, pLostAllocationCount);

-}

-

-VkResult vmaAllocateMemory(

-    VmaAllocator allocator,

-    const VkMemoryRequirements* pVkMemoryRequirements,

-    const VmaAllocationCreateInfo* pCreateInfo,

-    VmaAllocation* pAllocation,

-    VmaAllocationInfo* pAllocationInfo)

-{

-    VMA_ASSERT(allocator && pVkMemoryRequirements && pCreateInfo && pAllocation);

-

-    VMA_DEBUG_LOG("vmaAllocateMemory");

-

-    VMA_DEBUG_GLOBAL_MUTEX_LOCK

-

-	VkResult result = allocator->AllocateMemory(

-        *pVkMemoryRequirements,

-        false, // requiresDedicatedAllocation

-        false, // prefersDedicatedAllocation

-        VK_NULL_HANDLE, // dedicatedBuffer

-        VK_NULL_HANDLE, // dedicatedImage

-        *pCreateInfo,

-        VMA_SUBALLOCATION_TYPE_UNKNOWN,

-        pAllocation);

-

-    if(pAllocationInfo && result == VK_SUCCESS)

-    {

-        allocator->GetAllocationInfo(*pAllocation, pAllocationInfo);

-    }

-

-	return result;

-}

-

-VkResult vmaAllocateMemoryForBuffer(

-    VmaAllocator allocator,

-    VkBuffer buffer,

-    const VmaAllocationCreateInfo* pCreateInfo,

-    VmaAllocation* pAllocation,

-    VmaAllocationInfo* pAllocationInfo)

-{

-    VMA_ASSERT(allocator && buffer != VK_NULL_HANDLE && pCreateInfo && pAllocation);

-

-    VMA_DEBUG_LOG("vmaAllocateMemoryForBuffer");

-

-    VMA_DEBUG_GLOBAL_MUTEX_LOCK

-

-    VkMemoryRequirements vkMemReq = {};

-    bool requiresDedicatedAllocation = false;

-    bool prefersDedicatedAllocation = false;

-    allocator->GetBufferMemoryRequirements(buffer, vkMemReq,

-        requiresDedicatedAllocation,

-        prefersDedicatedAllocation);

-

-    VkResult result = allocator->AllocateMemory(

-        vkMemReq,

-        requiresDedicatedAllocation,

-        prefersDedicatedAllocation,

-        buffer, // dedicatedBuffer

-        VK_NULL_HANDLE, // dedicatedImage

-        *pCreateInfo,

-        VMA_SUBALLOCATION_TYPE_BUFFER,

-        pAllocation);

-

-    if(pAllocationInfo && result == VK_SUCCESS)

-    {

-        allocator->GetAllocationInfo(*pAllocation, pAllocationInfo);

-    }

-

-	return result;

-}

-

-VkResult 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

-

-    VkResult result = AllocateMemoryForImage(

-        allocator,

-        image,

-        pCreateInfo,

-        VMA_SUBALLOCATION_TYPE_IMAGE_UNKNOWN,

-        pAllocation);

-

-    if(pAllocationInfo && result == VK_SUCCESS)

-    {

-        allocator->GetAllocationInfo(*pAllocation, pAllocationInfo);

-    }

-

-	return result;

-}

-

-void vmaFreeMemory(

-    VmaAllocator allocator,

-    VmaAllocation allocation)

-{

-    VMA_ASSERT(allocator && allocation);

-

-    VMA_DEBUG_LOG("vmaFreeMemory");

-

-    VMA_DEBUG_GLOBAL_MUTEX_LOCK

-

-    allocator->FreeMemory(allocation);

-}

-

-void vmaGetAllocationInfo(

-    VmaAllocator allocator,

-    VmaAllocation allocation,

-    VmaAllocationInfo* pAllocationInfo)

-{

-    VMA_ASSERT(allocator && allocation && pAllocationInfo);

-

-    VMA_DEBUG_GLOBAL_MUTEX_LOCK

-

-    allocator->GetAllocationInfo(allocation, pAllocationInfo);

-}

-

-VkBool32 vmaTouchAllocation(

-    VmaAllocator allocator,

-    VmaAllocation allocation)

-{

-    VMA_ASSERT(allocator && allocation);

-

-    VMA_DEBUG_GLOBAL_MUTEX_LOCK

-

-    return allocator->TouchAllocation(allocation);

-}

-

-void vmaSetAllocationUserData(

-    VmaAllocator allocator,

-    VmaAllocation allocation,

-    void* pUserData)

-{

-    VMA_ASSERT(allocator && allocation);

-

-    VMA_DEBUG_GLOBAL_MUTEX_LOCK

-

-    allocation->SetUserData(allocator, pUserData);

-}

-

-void vmaCreateLostAllocation(

-    VmaAllocator allocator,

-    VmaAllocation* pAllocation)

-{

-    VMA_ASSERT(allocator && pAllocation);

-

-    VMA_DEBUG_GLOBAL_MUTEX_LOCK;

-

-    allocator->CreateLostAllocation(pAllocation);

-}

-

-VkResult vmaMapMemory(

-    VmaAllocator allocator,

-    VmaAllocation allocation,

-    void** ppData)

-{

-    VMA_ASSERT(allocator && allocation && ppData);

-

-    VMA_DEBUG_GLOBAL_MUTEX_LOCK

-

-    return allocator->Map(allocation, ppData);

-}

-

-void vmaUnmapMemory(

-    VmaAllocator allocator,

-    VmaAllocation allocation)

-{

-    VMA_ASSERT(allocator && allocation);

-

-    VMA_DEBUG_GLOBAL_MUTEX_LOCK

-

-    allocator->Unmap(allocation);

-}

-

-VkResult vmaDefragment(

-    VmaAllocator allocator,

-    VmaAllocation* pAllocations,

-    size_t allocationCount,

-    VkBool32* pAllocationsChanged,

-    const VmaDefragmentationInfo *pDefragmentationInfo,

-    VmaDefragmentationStats* pDefragmentationStats)

-{

-    VMA_ASSERT(allocator && pAllocations);

-

-    VMA_DEBUG_LOG("vmaDefragment");

-

-    VMA_DEBUG_GLOBAL_MUTEX_LOCK

-

-    return allocator->Defragment(pAllocations, allocationCount, pAllocationsChanged, pDefragmentationInfo, pDefragmentationStats);

-}

-

-VkResult 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, buffer);

-}

-

-VkResult 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, image);

-}

-

-VkResult vmaCreateBuffer(

-    VmaAllocator allocator,

-    const VkBufferCreateInfo* pBufferCreateInfo,

-    const VmaAllocationCreateInfo* pAllocationCreateInfo,

-    VkBuffer* pBuffer,

-    VmaAllocation* pAllocation,

-    VmaAllocationInfo* pAllocationInfo)

-{

-    VMA_ASSERT(allocator && pBufferCreateInfo && pAllocationCreateInfo && pBuffer && pAllocation);

-    

-    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);

-

-         // Make sure alignment requirements for specific buffer usages reported

-         // in Physical Device Properties are included in alignment reported by memory requirements.

-        if((pBufferCreateInfo->usage & VK_BUFFER_USAGE_UNIFORM_TEXEL_BUFFER_BIT) != 0)

-        {

-           VMA_ASSERT(vkMemReq.alignment %

-              allocator->m_PhysicalDeviceProperties.limits.minTexelBufferOffsetAlignment == 0);

-        }

-        if((pBufferCreateInfo->usage & VK_BUFFER_USAGE_UNIFORM_BUFFER_BIT) != 0)

-        {

-           VMA_ASSERT(vkMemReq.alignment %

-              allocator->m_PhysicalDeviceProperties.limits.minUniformBufferOffsetAlignment == 0);

-        }

-        if((pBufferCreateInfo->usage & VK_BUFFER_USAGE_STORAGE_BUFFER_BIT) != 0)

-        {

-           VMA_ASSERT(vkMemReq.alignment %

-              allocator->m_PhysicalDeviceProperties.limits.minStorageBufferOffsetAlignment == 0);

-        }

-

-        // 3. Allocate memory using allocator.

-        res = allocator->AllocateMemory(

-            vkMemReq,

-            requiresDedicatedAllocation,

-            prefersDedicatedAllocation,

-            *pBuffer, // dedicatedBuffer

-            VK_NULL_HANDLE, // dedicatedImage

-            *pAllocationCreateInfo,

-            VMA_SUBALLOCATION_TYPE_BUFFER,

-            pAllocation);

-        if(res >= 0)

-        {

-            // 3. Bind buffer with memory.

-            res = allocator->BindBufferMemory(*pAllocation, *pBuffer);

-            if(res >= 0)

-            {

-                // All steps succeeded.

-                if(pAllocationInfo != VMA_NULL)

-                {

-                    allocator->GetAllocationInfo(*pAllocation, pAllocationInfo);

-                }

-                return VK_SUCCESS;

-            }

-            allocator->FreeMemory(*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;

-}

-

-void vmaDestroyBuffer(

-    VmaAllocator allocator,

-    VkBuffer buffer,

-    VmaAllocation allocation)

-{

-    if(buffer != VK_NULL_HANDLE)

-    {

-        VMA_ASSERT(allocator);

-

-        VMA_DEBUG_LOG("vmaDestroyBuffer");

-

-        VMA_DEBUG_GLOBAL_MUTEX_LOCK

-

-        (*allocator->GetVulkanFunctions().vkDestroyBuffer)(allocator->m_hDevice, buffer, allocator->GetAllocationCallbacks());

-        

-        allocator->FreeMemory(allocation);

-    }

-}

-

-VkResult vmaCreateImage(

-    VmaAllocator allocator,

-    const VkImageCreateInfo* pImageCreateInfo,

-    const VmaAllocationCreateInfo* pAllocationCreateInfo,

-    VkImage* pImage,

-    VmaAllocation* pAllocation,

-    VmaAllocationInfo* pAllocationInfo)

-{

-    VMA_ASSERT(allocator && pImageCreateInfo && pAllocationCreateInfo && pImage && pAllocation);

-

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

-        res = AllocateMemoryForImage(allocator, *pImage, pAllocationCreateInfo, suballocType, pAllocation);

-        if(res >= 0)

-        {

-            // 3. Bind image with memory.

-            res = allocator->BindImageMemory(*pAllocation, *pImage);

-            if(res >= 0)

-            {

-                // All steps succeeded.

-                if(pAllocationInfo != VMA_NULL)

-                {

-                    allocator->GetAllocationInfo(*pAllocation, pAllocationInfo);

-                }

-                return VK_SUCCESS;

-            }

-            allocator->FreeMemory(*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;

-}

-

-void vmaDestroyImage(

-    VmaAllocator allocator,

-    VkImage image,

-    VmaAllocation allocation)

-{

-    if(image != VK_NULL_HANDLE)

-    {

-        VMA_ASSERT(allocator);

-

-        VMA_DEBUG_LOG("vmaDestroyImage");

-

-        VMA_DEBUG_GLOBAL_MUTEX_LOCK

-

-        (*allocator->GetVulkanFunctions().vkDestroyImage)(allocator->m_hDevice, image, allocator->GetAllocationCallbacks());

-

-        allocator->FreeMemory(allocation);

-    }

-}

-

-#endif // #ifdef VMA_IMPLEMENTATION