public static void vkUnmapMemory(VkDevice device, VkDeviceMemory memory)
{
VkPreconditions.CheckNull(device, nameof(device));
VkPreconditions.CheckNull(memory, nameof(memory));
GetDevice(device).UnmapMemory(memory);
}
public static VkResult vkMapMemory(VkDevice device, VkDeviceMemory memory, int offset, int size, int memoryMapFlags, out byte[] ppData)
{
VkPreconditions.CheckNull(device, nameof(device));
VkPreconditions.CheckNull(memory, nameof(memory));
return(GetDevice(device).MapMemory(memory, offset, size, memoryMapFlags, out ppData));
}
public VkMemoryBlock(VkDeviceMemory memory, ulong offset, ulong size, uint memoryTypeIndex)
{
DeviceMemory = memory;
Offset = offset;
Size = size;
MemoryTypeIndex = memoryTypeIndex;
}
public static IntPtr MapMemory(VkDeviceMemory memory, ulong offset, ulong size, VkMemoryMapFlags flags)
{
void *mappedLocal;
vkMapMemory(device, memory, offset, size, flags, &mappedLocal);
return((IntPtr)mappedLocal);
}
internal static unsafe void AllocatePool(out VkDeviceMemory NativeMemory, ref VkDevice device, ref VkPhysicalDevice pDevice, ref VkMemoryPropertyFlags memoryProperties, ref VkMemoryRequirements memoryRequirements, ulong size)
{
var allocateInfo = new VkMemoryAllocateInfo
{
sType = VkStructureType.MemoryAllocateInfo,
allocationSize = size,
};
Vortice.Vulkan.Vulkan.vkGetPhysicalDeviceMemoryProperties(pDevice, out var physicalDeviceMemoryProperties);
var typeBits = memoryRequirements.memoryTypeBits;
for (uint i = 0; i < physicalDeviceMemoryProperties.memoryTypeCount; i++)
{
if ((typeBits & 1) == 1)
{
// Type is available, does it match user properties?
var memoryType = *(&physicalDeviceMemoryProperties.memoryTypes_0 + i);
if ((memoryType.propertyFlags & memoryProperties) == memoryProperties)
{
allocateInfo.memoryTypeIndex = i;
break;
}
}
typeBits >>= 1;
}
NativeMemory = new VkDeviceMemory();
Vortice.Vulkan.Vulkan.vkAllocateMemory(device, &allocateInfo, null, out NativeMemory);
}
private unsafe void ReleaseDevice()
{
EmptyTexelBufferInt.Dispose();
EmptyTexelBufferInt = null;
EmptyTexelBufferFloat.Dispose();
EmptyTexelBufferFloat = null;
EmptyTexture.Dispose();
EmptyTexture = null;
// Wait for all queues to be idle
vkDeviceWaitIdle(nativeDevice);
// Destroy all remaining fences
GetCompletedValue();
// Mark upload buffer for destruction
if (nativeUploadBuffer != VkBuffer.Null)
{
vkUnmapMemory(NativeDevice, nativeUploadBufferMemory);
nativeResourceCollector.Add(lastCompletedFence, nativeUploadBuffer);
nativeResourceCollector.Add(lastCompletedFence, nativeUploadBufferMemory);
nativeUploadBuffer = VkBuffer.Null;
nativeUploadBufferMemory = VkDeviceMemory.Null;
}
// Release fenced resources
nativeResourceCollector.Dispose();
DescriptorPools.Dispose();
vkDestroyCommandPool(nativeDevice, NativeCopyCommandPool, null);
vkDestroyDevice(nativeDevice, null);
}
private void DisposeVulkanDeviceMemory(VkDeviceMemory vulkanDeviceMemory)
{
if (vulkanDeviceMemory != VK_NULL_HANDLE)
{
vkFreeMemory(Collection.Allocator.Device.VulkanDevice, vulkanDeviceMemory, pAllocator: null);
}
}
void CreateImage(int width, int height,
VkFormat format, VkImageTiling tiling, VkImageUsageFlags usage, VkMemoryPropertyFlags properties,
out VkImage image, out VkDeviceMemory memory)
{
var info = new VkImageCreateInfo();
info.imageType = VkImageType._2D;
info.extent.width = width;
info.extent.height = height;
info.extent.depth = 1;
info.mipLevels = 1;
info.arrayLayers = 1;
info.format = format;
info.tiling = tiling;
info.initialLayout = VkImageLayout.Undefined;
info.usage = usage;
info.sharingMode = VkSharingMode.Exclusive;
info.samples = VkSampleCountFlags._1_Bit;
image = new VkImage(device, info);
var req = image.Requirements;
var allocInfo = new VkMemoryAllocateInfo();
allocInfo.allocationSize = req.size;
allocInfo.memoryTypeIndex = FindMemoryType(req.memoryTypeBits, properties);
memory = new VkDeviceMemory(device, allocInfo);
image.Bind(memory, 0);
}
private VulkanBuffer(VkDevice device, VkCommandPool commandPool, VkBuffer buffer, VkDeviceMemory memory, int count)
{
Buffer = buffer;
Memory = memory;
Count = count;
this.device = device;
this.commandPool = commandPool;
}
public static VkResult vkBindImageMemory(VkDevice device, VkImage image, VkDeviceMemory memory, int memoryOffset)
{
VkPreconditions.CheckNull(device, nameof(device));
VkPreconditions.CheckNull(image, nameof(image));
VkPreconditions.CheckNull(memory, nameof(memory));
return(GetDevice(device).BindImageMemory(image, memory, memoryOffset));
}
private VulkanImage(VulkanContext ctx, VkImage image, VkDeviceMemory memory, VkImageView view, VkFormat format)
{
Image = image;
Memory = memory;
View = view;
Format = format;
this.ctx = ctx;
}
public MemoryAllocation(VkDeviceMemory handle, ulong off, ulong size,
VkMemoryPropertyFlags flags)
{
Handle = handle;
Offset = off;
Size = size;
Flags = flags;
}
public VkMemoryBlock(VkDeviceMemory memory, ulong offset, ulong size, uint memoryTypeIndex, void *mappedPtr)
{
DeviceMemory = memory;
Offset = offset;
Size = size;
MemoryTypeIndex = memoryTypeIndex;
BaseMappedPointer = mappedPtr;
}
public static extern VkResult MapMemory(
VkDevice device,
VkDeviceMemory memory,
ulong offset,
ulong size,
VkMemoryMapFlags flags,
out IntPtr ppData
);
public static VkResult vkBindBufferMemory(VkDevice device, VkBuffer buffer, VkDeviceMemory memory, int memoryOffset)
{
VkPreconditions.CheckNull(device, nameof(device));
VkPreconditions.CheckNull(buffer, nameof(buffer));
VkPreconditions.CheckNull(memory, nameof(memory));
VkPreconditions.CheckRange(memoryOffset, 0, int.MaxValue, nameof(memoryOffset));
return(GetDevice(device).BindBufferMemory(buffer, memory, memoryOffset));
}
public override void FreeMemory(VkDeviceMemory memory)
{
SoftwareDeviceMemory mem = (SoftwareDeviceMemory)memory;
if (mem != null)
{
m_DeviceMemory.Remove(mem);
mem.Destroy();
}
}
public override VkResult AllocateMemory(VkMemoryAllocateInfo pAllocateInfo, out VkDeviceMemory pMemory)
{
VkPreconditions.CheckRange(pAllocateInfo.allocationSize, 1, int.MaxValue, nameof(pAllocateInfo.allocationSize));
VkPreconditions.CheckRange(pAllocateInfo.memoryTypeIndex != 0, nameof(pAllocateInfo.memoryTypeIndex));
var ret = new SoftwareDeviceMemory(this, pAllocateInfo);
m_DeviceMemory.Add(ret);
pMemory = ret;
return(VkResult.VK_SUCCESS);
}
internal VulkanMemorySlice(VulkanMemoryPool originPool, ulong size, ulong offset, ulong alignOffset, VkDeviceMemory vkDeviceMemory, uint memoryTypeIndex, VkMemoryPropertyFlags memoryPropertyFlags)
{
this.originPool = originPool;
this.memoryTypeIndex = memoryTypeIndex;
this.memoryPropertyFlags = memoryPropertyFlags;
this.vkDeviceMemory = vkDeviceMemory;
this.size = size;
this.offset = offset;
this.alignOffset = alignOffset;
disposed = false;
hostVisible = (memoryPropertyFlags & VkMemoryPropertyFlags.HostVisible) != 0;
}
public void FlushMappedMemoryRanges()
{
// Flush to make changes visible to the host
VkMappedMemoryRange memory_range = new()
{
sType = VkStructureType.MappedMemoryRange,
memory = memory,
size = (ulong)SizeInBytes,
};
vkFlushMappedMemoryRanges(NativeDevice.handle, 1, &memory_range).CheckResult();
}
public unsafe VkMappedMemoryRange(
VkDeviceMemory memory,
ulong offset = 0,
ulong size = Vulkan.WholeSize,
void *pNext = default)
{
sType = VkStructureType.MappedMemoryRange;
this.pNext = pNext;
this.memory = memory;
this.offset = offset;
this.size = size;
}
public static Span <T> vkMapMemory <T>(VkDevice device, VkBuffer buffer, VkDeviceMemory memory, ulong offset = 0, ulong size = WholeSize, VkMemoryMapFlags flags = VkMemoryMapFlags.None) where T : unmanaged
{
void *pData;
vkMapMemory(device, memory, offset, size, flags, &pData).CheckResult();
if (size == WholeSize)
{
vkGetBufferMemoryRequirements(device, buffer, out var memoryRequirements);
return(new Span <T>(pData, (int)memoryRequirements.size));
}
return(new Span <T>(pData, (int)size));
}
public VkMemoryBlock(
VkDeviceMemory memory,
ulong offset,
ulong size,
uint memoryTypeIndex,
void *mappedPtr,
bool dedicatedAllocation)
{
DeviceMemory = memory;
Offset = offset;
Size = size;
MemoryTypeIndex = memoryTypeIndex;
BaseMappedPointer = mappedPtr;
DedicatedAllocation = dedicatedAllocation;
}
public static Span <T> vkMapMemory <T>(VkDevice device, VkImage image, VkDeviceMemory memory, ulong offset = 0, ulong size = WholeSize, VkMemoryMapFlags flags = VkMemoryMapFlags.None) where T : unmanaged
{
void *pData;
vkMapMemory(device, memory, offset, size, flags, &pData).CheckResult();
if (size == WholeSize)
{
vkGetImageMemoryRequirements(device, image, out VkMemoryRequirements memoryRequirements);
size = memoryRequirements.size;
}
int oneItemSize = sizeof(T);
int spanLength = (int)size / oneItemSize;
return(new Span <T>(pData, spanLength));
}
void CreateBuffer(long size, VkBufferUsageFlags usage, VkMemoryPropertyFlags properties, out VkBuffer buffer, out VkDeviceMemory memory)
{
var info = new VkBufferCreateInfo();
info.size = size;
info.usage = usage;
info.sharingMode = VkSharingMode.Exclusive;
buffer = new VkBuffer(device, info);
var allocInfo = new VkMemoryAllocateInfo();
allocInfo.allocationSize = buffer.Requirements.size;
allocInfo.memoryTypeIndex = FindMemoryType(buffer.Requirements.memoryTypeBits, properties);
memory = new VkDeviceMemory(device, allocInfo);
buffer.Bind(memory, 0);
}
private void CreateDepthImage(VkPhysicalDevice physicalDevice, uint width, uint height)
{
VkImageCreateInfo createInfo = VkImageCreateInfo.New();
createInfo.imageType = VkImageType.Image2D;
createInfo.extent.width = width;
createInfo.extent.height = height;
createInfo.extent.depth = 1;
createInfo.mipLevels = 1;
createInfo.arrayLayers = 1;
createInfo.format = VkFormat.D32Sfloat;
createInfo.tiling = VkImageTiling.Optimal;
createInfo.initialLayout = VkImageLayout.Undefined;
createInfo.usage = VkImageUsageFlags.DepthStencilAttachment;
createInfo.sharingMode = VkSharingMode.Exclusive;
createInfo.samples = VkSampleCountFlags.Count1;
VkImage depthImage;
Assert(vkCreateImage(device, &createInfo, null, &depthImage));
VkMemoryRequirements memoryRequirements;
vkGetImageMemoryRequirements(device, depthImage, &memoryRequirements);
VkPhysicalDeviceMemoryProperties memoryProperties = new VkPhysicalDeviceMemoryProperties();
vkGetPhysicalDeviceMemoryProperties(physicalDevice, &memoryProperties);
VkMemoryAllocateInfo allocateInfo = VkMemoryAllocateInfo.New();
allocateInfo.allocationSize = memoryRequirements.size;
allocateInfo.memoryTypeIndex = FDataBuffer <byte> .SelectMemoryType(memoryProperties, memoryRequirements.memoryTypeBits,
VkMemoryPropertyFlags.DeviceLocal);
VkDeviceMemory depthImageMemory;
Assert(vkAllocateMemory(device, &allocateInfo, null, &depthImageMemory));
vkBindImageMemory(device, depthImage, depthImageMemory, 0);
this.depthImage = depthImage;
this.depthImageMemory = depthImageMemory;
}
public void UpdateSize()
{
if (width == originalWidth)
{
width = originalWidth / 2;
height = originalHeight / 2;
}
else
{
width = originalWidth;
height = originalHeight;
}
var uniformBufferData = new AreaUniformBuffer(width, height);
var length = 1;
var size = System.Runtime.InteropServices.Marshal.SizeOf(typeof(AreaUniformBuffer)) * length;
VkDevice device = this.device; VkDeviceMemory deviceMemory = this.vkDeviceMemory;
{
IntPtr memPtr = IntPtr.Zero;
vkAPI.vkMapMemory(device, deviceMemory, 0, (UInt64)size, 0, &memPtr).Check();
System.Runtime.InteropServices.Marshal.StructureToPtr(uniformBufferData, memPtr, false);
//GCHandle pin = GCHandle.Alloc(uniformBufferData, GCHandleType.Pinned);
//IntPtr address = pin.AddrOfPinnedObject();
//var src = (byte*)address;
//var dst = (byte*)memPtr;
//for (int i = 0; i < size; i++) {
// dst[i] = src[i];
//}
//pin.Free();
//// Flush to make changes visible to the host
//var memoryRange = new VkMappedMemoryRange();
//{
// memoryRange.sType = VK_STRUCTURE_TYPE_MAPPED_MEMORY_RANGE;
// memoryRange.memory = deviceMemory;
// memoryRange.size = this.uniformSize;
//}
//vkAPI.vkFlushMappedMemoryRanges(device, 1, &memoryRange);
vkAPI.vkUnmapMemory(device, deviceMemory);
}
}
public FDataBuffer(VkDevice device, VkPhysicalDevice physicalDevice, int length, VkBufferUsageFlags usage, VkSharingMode sharingMode)
{
this.device = device;
VkBufferCreateInfo createInfo = VkBufferCreateInfo.New();
size = (ulong)(sizeof(T) * length);
createInfo.size = size;
createInfo.usage = usage;
createInfo.sharingMode = sharingMode;
VkBuffer buffer = VkBuffer.Null;
Assert(vkCreateBuffer(device, &createInfo, null, &buffer));
this.Buffer = buffer;
VkMemoryRequirements memoryRequirements = new VkMemoryRequirements();
vkGetBufferMemoryRequirements(device, this.Buffer, &memoryRequirements);
VkPhysicalDeviceMemoryProperties memoryProperties = new VkPhysicalDeviceMemoryProperties();
vkGetPhysicalDeviceMemoryProperties(physicalDevice, &memoryProperties);
VkMemoryAllocateInfo allocateInfo = VkMemoryAllocateInfo.New();
allocateInfo.allocationSize = memoryRequirements.size;
allocateInfo.memoryTypeIndex = SelectMemoryType(memoryProperties, memoryRequirements.memoryTypeBits,
VkMemoryPropertyFlags.HostVisible | VkMemoryPropertyFlags.HostCoherent);
VkDeviceMemory memory = new VkDeviceMemory();
Assert(vkAllocateMemory(device, &allocateInfo, null, &memory));
Memory = memory;
Assert(vkBindBufferMemory(device, this.Buffer, memory, 0));
spanLength = length;
}
VkBuffer CreateBuffer(VkPhysicalDevice physicalDevice, VkDevice device, object values, VkBufferUsageFlagBits usageFlags, System.Type type)
{
var array = values as System.Array;
var length = (array != null) ? array.Length : 1;
var size = System.Runtime.InteropServices.Marshal.SizeOf(type) * length;
VkBuffer buffer;
{
UInt32 index = 0;
var info = new VkBufferCreateInfo {
sType = VkStructureType.BufferCreateInfo
};
info.size = (UInt64)size;
info.usage = usageFlags;
info.sharingMode = VkSharingMode.Exclusive;
info.queueFamilyIndices = index;
//VkBuffer buffer = device.CreateBuffer(ref info);
vkAPI.vkCreateBuffer(device, &info, null, &buffer).Check();
info.Free();
}
VkDeviceMemory deviceMemory; // = device.AllocateMemory(ref allocInfo);
VkMemoryRequirements memoryReq;
//VkMemoryRequirements memoryReq = device.GetBufferMemoryRequirements(buffer);
vkAPI.vkGetBufferMemoryRequirements(device, buffer, &memoryReq);
var allocInfo = new VkMemoryAllocateInfo {
sType = VkStructureType.MemoryAllocateInfo
};
{
allocInfo.allocationSize = memoryReq.size;
VkPhysicalDeviceMemoryProperties memoryProperties;
vkAPI.vkGetPhysicalDeviceMemoryProperties(physicalDevice, &memoryProperties);
allocInfo.memoryTypeIndex = GetMemoryTypeIndex(memoryProperties, memoryReq,
VkMemoryPropertyFlagBits.HostVisible | VkMemoryPropertyFlagBits.HostCoherent);
vkAPI.vkAllocateMemory(device, &allocInfo, null, &deviceMemory).Check();
}
{
IntPtr memPtr = IntPtr.Zero;
vkAPI.vkMapMemory(device, deviceMemory, 0, (UInt64)size, 0, &memPtr).Check();
if (type == typeof(float))
{
System.Runtime.InteropServices.Marshal.Copy(values as float[], 0, memPtr, length);
}
else if (type == typeof(short))
{
System.Runtime.InteropServices.Marshal.Copy(values as short[], 0, memPtr, length);
}
else if (type == typeof(AreaUniformBuffer))
{
System.Runtime.InteropServices.Marshal.StructureToPtr(values, memPtr, false);
this.vkBuffer = buffer;
this.vkDeviceMemory = deviceMemory;
this.uniformSize = memoryReq.size;
}
vkAPI.vkUnmapMemory(device, deviceMemory);
}
vkAPI.vkBindBufferMemory(device, buffer, deviceMemory, 0).Check();
return(buffer);
}
public static void vkFreeMemory(VkDevice device, VkDeviceMemory memory, VkAllocationCallbacks pAllocator)
{
VkPreconditions.CheckNull(device, nameof(device));
GetDevice(device).FreeMemory(memory);
}
public static VkResult vkAllocateMemory(VkDevice device, VkMemoryAllocateInfo pAllocateInfo, VkAllocationCallbacks pAllocator, out VkDeviceMemory pMemory)
{
VkPreconditions.CheckNull(device, nameof(device));
return(GetDevice(device).AllocateMemory(pAllocateInfo, out pMemory));
}
