diff --git a/src/Vulkan/VMASharp_API_For_Review.md b/src/Vulkan/VMASharp_API_For_Review.md
new file mode 100644
index 0000000000..7f64fc47e2
--- /dev/null
+++ b/src/Vulkan/VMASharp_API_For_Review.md
@@ -0,0 +1,305 @@
+```cs
+namespace VMASharp.Metadata
+{
+ public interface IBlockMetadata
+ {
+ long Size { get; }
+ int AllocationCount { get; }
+ long SumFreeSize { get; }
+ long UnusedRangeSizeMax { get; }
+ bool IsEmpty { get; }
+ void Validate();
+ void CalcAllocationStatInfo(out StatInfo outInfo);
+ void AddPoolStats(ref PoolStats stats);
+ bool TryCreateAllocationRequest(in AllocationContext context, out AllocationRequest request);
+ bool MakeRequestedAllocationsLost(
+ int currentFrame,
+ int frameInUseCount,
+ ref AllocationRequest request);
+ int MakeAllocationsLost(int currentFrame, int frameInUseCount);
+ void CheckCorruption(nuint blockDataPointer);
+ void Alloc(
+ in AllocationRequest request,
+ SuballocationType type,
+ long allocSize,
+ BlockAllocation allocation);
+ void Free(BlockAllocation allocation);
+ void FreeAtOffset(long offset);
+ }
+}
+namespace VMASharp
+{
+ public abstract class Allocation : IDisposable
+ {
+ public long Size { get; }
+ public int MemoryTypeIndex { get; }
+ public abstract DeviceMemory DeviceMemory { get; }
+ public abstract long Offset { get; internal set; }
+ public object? UserData { get; set; }
+ public abstract nint MappedData { get; }
+ public void Dispose();
+ public Result BindBufferMemory(Buffer buffer);
+ public Result BindBufferMemory(Buffer buffer, long allocationLocalOffset, nint pNext);
+ public Result BindBufferMemory(Buffer buffer, long allocationLocalOffset, void* pNext = null);
+ public Result BindImageMemory(Image image);
+ public Result BindImageMemory(Image image, long allocationLocalOffset, nint pNext);
+ public Result BindImageMemory(Image image, long allocationLocalOffset, void* pNext = null);
+ public bool TouchAllocation();
+ public Result Flush(long offset, long size);
+ public Result Invalidate(long offset, long size);
+ public abstract nint Map();
+ public abstract void Unmap();
+ public bool TryGetMemory<T>(out Memory<T> memory) where T : unmanaged;
+ public bool TryGetSpan<T>(out Span<T> span) where T : unmanaged;
+ }
+ public struct AllocationBudget
+ {
+ public long BlockBytes;
+ public long AllocationBytes;
+ public long Usage;
+ public long Budget;
+ public AllocationBudget(long blockBytes, long allocationBytes, long usage, long budget);
+ }
+ public struct AllocationContext
+ {
+ public int CurrentFrame;
+ public int FrameInUseCount;
+ public long BufferImageGranularity;
+ public long AllocationSize;
+ public long AllocationAlignment;
+ public AllocationStrategyFlags Strategy;
+ public SuballocationType SuballocationType;
+ public bool CanMakeOtherLost;
+ public AllocationContext(
+ int currentFrame,
+ int framesInUse,
+ long bufferImageGranularity,
+ long allocationSize,
+ long allocationAlignment,
+ AllocationStrategyFlags strategy,
+ SuballocationType suballocType,
+ bool canMakeOtherLost);
+ }
+ [Flags]
+ public enum AllocationCreateFlags
+ {
+ DedicatedMemory = 1,
+ NeverAllocate = 2,
+ Mapped = 4,
+ CanBecomeLost = 8,
+ CanMakeOtherLost = 16, // 0x00000010
+ UpperAddress = 64, // 0x00000040
+ DontBind = 128, // 0x00000080
+ WithinBudget = 256, // 0x00000100
+ }
+ public struct AllocationCreateInfo
+ {
+ public AllocationCreateFlags Flags;
+ public AllocationStrategyFlags Strategy;
+ public MemoryUsage Usage;
+ public MemoryPropertyFlags? RequiredFlags;
+ public MemoryPropertyFlags? PreferredFlags;
+ public uint MemoryTypeBits;
+ public VulkanMemoryPool? Pool;
+ public object? UserData;
+ public AllocationCreateInfo(
+ AllocationCreateFlags flags = (AllocationCreateFlags) 0,
+ AllocationStrategyFlags strategy = (AllocationStrategyFlags) 0,
+ MemoryUsage usage = MemoryUsage.Unknown,
+ MemoryPropertyFlags? requiredFlags = 0,
+ MemoryPropertyFlags? preferredFlags = 0,
+ uint memoryTypeBits = 0,
+ VulkanMemoryPool? pool = null,
+ object? userData = null);
+ }
+ public class AllocationException : VulkanResultException
+ {
+ public AllocationException(string message);
+ public AllocationException(string message, Exception? innerException);
+ public AllocationException(Result res);
+ public AllocationException(string message, Result res);
+ }
+ public struct AllocationPoolCreateInfo
+ {
+ public int MemoryTypeIndex;
+ public PoolCreateFlags Flags;
+ public long BlockSize;
+ public int MinBlockCount;
+ public int MaxBlockCount;
+ public int FrameInUseCount;
+ public Func<long, IBlockMetadata>? AllocationAlgorithmCreate;
+ public AllocationPoolCreateInfo(
+ int memoryTypeIndex,
+ PoolCreateFlags flags = (PoolCreateFlags) 0,
+ long blockSize = 0,
+ int minBlockCount = 0,
+ int maxBlockCount = 0,
+ int frameInUseCount = 0,
+ Func<long, IBlockMetadata>? allocationAlgorithemCreate = null);
+ }
+ public struct AllocationRequest
+ {
+ public const long LostAllocationCost = 1048576;
+ public long Offset;
+ public long SumFreeSize;
+ public long SumItemSize;
+ public long ItemsToMakeLostCount;
+ public object Item;
+ public object CustomData;
+ public AllocationRequestType Type;
+ public readonly long CalcCost();
+ }
+ public enum AllocationRequestType
+ {
+ Normal,
+ UpperAddress
+ }
+ [Flags]
+ public enum AllocationStrategyFlags
+ {
+ BestFit = 1,
+ WorstFit = 2,
+ FirstFit = 4,
+ MinMemory = BestFit, // 0x00000001
+ MinTime = FirstFit, // 0x00000004
+ MinFragmentation = WorstFit, // 0x00000002
+ }
+ [Flags]
+ public enum AllocatorCreateFlags
+ {
+ ExternallySyncronized = 1,
+ ExtMemoryBudget = 8,
+ AMDDeviceCoherentMemory = 16, // 0x00000010
+ BufferDeviceAddress = 32, // 0x00000020
+ }
+ public sealed class BlockAllocation : Allocation
+ {
+ public override DeviceMemory DeviceMemory { get; }
+ public override long Offset { get; internal set; }
+ public override nint MappedData { get; }
+ public override nint Map();
+ public override void Unmap();
+ }
+ public class MapMemoryException : VulkanResultException
+ {
+ public MapMemoryException(string message);
+ public MapMemoryException(Result res);
+ public MapMemoryException(string message, Result res);
+ }
+ public enum MemoryUsage
+ {
+ Unknown,
+ GPU_Only,
+ CPU_Only,
+ CPU_To_GPU,
+ GPU_To_CPU,
+ CPU_Copy,
+ GPU_LazilyAllocated,
+ }
+ [Flags]
+ public enum PoolCreateFlags
+ {
+ IgnoreBufferImageGranularity = 1,
+ LinearAlgorithm = 16, // 0x00000010
+ BuddyAlgorithm = 32, // 0x00000020
+ }
+ public struct PoolStats
+ {
+ public long Size;
+ public long UnusedSize;
+ public int AllocationCount;
+ public int UnusedRangeCount;
+ public long UnusedRangeSizeMax;
+ public int BlockCount;
+ }
+ public struct StatInfo
+ {
+ public int BlockCount;
+ public int AllocationCount;
+ public int UnusedRangeCount;
+ public long UsedBytes;
+ public long UnusedBytes;
+ public long AllocationSizeMin;
+ public long AllocationSizeAvg;
+ public long AllocationSizeMax;
+ public long UnusedRangeSizeMin;
+ public long UnusedRangeSizeAvg;
+ public long UnusedRangeSizeMax;
+ }
+ public class Stats
+ {
+ public readonly StatInfo[] MemoryType;
+ public readonly StatInfo[] MemoryHeap;
+ public StatInfo Total;
+ }
+ public enum SuballocationType
+ {
+ Free,
+ Unknown,
+ Buffer,
+ Image_Unknown,
+ Image_Linear,
+ Image_Optimal,
+ }
+ public class ValidationFailedException : ApplicationException
+ {
+ }
+ public sealed class VulkanMemoryAllocator : IDisposable
+ {
+ public Device Device { get; }
+ public VulkanMemoryAllocator(in VulkanMemoryAllocatorCreateInfo createInfo);
+ public int CurrentFrameIndex { get; set; }
+ public void Dispose();
+ public ref readonly Silk.NET.Vulkan.PhysicalDeviceProperties PhysicalDeviceProperties { get; }
+ public ref readonly PhysicalDeviceMemoryProperties MemoryProperties { get; }
+ public MemoryPropertyFlags GetMemoryTypeProperties(int memoryTypeIndex);
+ public int? FindMemoryTypeIndex(uint memoryTypeBits, in AllocationCreateInfo allocInfo);
+ public int? FindMemoryTypeIndexForBufferInfo(
+ in BufferCreateInfo bufferInfo,
+ in AllocationCreateInfo allocInfo);
+ public int? FindMemoryTypeIndexForImageInfo(
+ in ImageCreateInfo imageInfo,
+ in AllocationCreateInfo allocInfo);
+ public Allocation AllocateMemory(
+ in MemoryRequirements requirements,
+ in AllocationCreateInfo createInfo);
+ public Allocation AllocateMemoryForBuffer(
+ Buffer buffer,
+ in AllocationCreateInfo createInfo,
+ bool BindToBuffer = false);
+ public Allocation AllocateMemoryForImage(
+ Image image,
+ in AllocationCreateInfo createInfo,
+ bool BindToImage = false);
+ public Result CheckCorruption(uint memoryTypeBits);
+ public Buffer CreateBuffer(
+ in BufferCreateInfo bufferInfo,
+ in AllocationCreateInfo allocInfo,
+ out Allocation allocation);
+ public Image CreateImage(
+ in ImageCreateInfo imageInfo,
+ in AllocationCreateInfo allocInfo,
+ out Allocation allocation);
+ public void FreeMemory(Allocation allocation);
+ public Stats CalculateStats();
+ public VulkanMemoryPool CreatePool(in AllocationPoolCreateInfo createInfo);
+ }
+ public sealed class VulkanMemoryPool : IDisposable
+ {
+ public VulkanMemoryAllocator Allocator { get; }
+ public string Name { get; set; }
+ public void Dispose();
+ public int MakeAllocationsLost();
+ public Result CheckForCorruption();
+ public void GetPoolStats(out PoolStats stats);
+ }
+ public class VulkanResultException : ApplicationException
+ {
+ public readonly Silk.NET.Vulkan.Result? Result;
+ public VulkanResultException(string message);
+ public VulkanResultException(string message, Exception? innerException);
+ public VulkanResultException(Silk.NET.Vulkan.Result res);
+ public VulkanResultException(string message, Silk.NET.Vulkan.Result res);
+ }
+}
+```