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(out Memory memory) where T : unmanaged; + public bool TryGetSpan(out Span 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? AllocationAlgorithmCreate; + public AllocationPoolCreateInfo( + int memoryTypeIndex, + PoolCreateFlags flags = (PoolCreateFlags) 0, + long blockSize = 0, + int minBlockCount = 0, + int maxBlockCount = 0, + int frameInUseCount = 0, + Func? 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); + } +} +```