protected unsafe DeviceMemory AllocateMemory(MemoryPropertyFlags memoryProperties, MemoryRequirements memoryRequirements)
{
var allocateInfo = new MemoryAllocateInfo
{
StructureType = StructureType.MemoryAllocateInfo,
AllocationSize = memoryRequirements.Size,
};
PhysicalDeviceMemoryProperties physicalDeviceMemoryProperties;
physicalDevice.GetMemoryProperties(out 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 = *((MemoryType *)&physicalDeviceMemoryProperties.MemoryTypes + i);
if ((memoryType.PropertyFlags & memoryProperties) == memoryProperties)
{
allocateInfo.MemoryTypeIndex = i;
break;
}
}
typeBits >>= 1;
}
return(device.AllocateMemory(ref allocateInfo));
}
protected unsafe void AllocateMemory(MemoryPropertyFlags memoryProperties, MemoryRequirements memoryRequirements)
{
if (NativeMemory != DeviceMemory.Null)
return;
if (memoryRequirements.Size == 0)
return;
var allocateInfo = new MemoryAllocateInfo
{
StructureType = StructureType.MemoryAllocateInfo,
AllocationSize = memoryRequirements.Size,
};
PhysicalDeviceMemoryProperties physicalDeviceMemoryProperties;
GraphicsDevice.NativePhysicalDevice.GetMemoryProperties(out 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 = *((MemoryType*)&physicalDeviceMemoryProperties.MemoryTypes + i);
if ((memoryType.PropertyFlags & memoryProperties) == memoryProperties)
{
allocateInfo.MemoryTypeIndex = i;
break;
}
}
typeBits >>= 1;
}
NativeMemory = GraphicsDevice.NativeDevice.AllocateMemory(ref allocateInfo);
}
public MemoryType
(
MemoryPropertyFlags propertyFlags = default,
uint heapIndex = default
)
{
PropertyFlags = propertyFlags;
HeapIndex = heapIndex;
}
public MemoryAllocation AllocateDeviceMemory(
PhysicalDevice physicalDevice,
MemoryRequirements requirements,
MemoryPropertyFlags flags = 0)
{
int memoryTypeIndex = FindSuitableMemoryTypeIndex(_api, physicalDevice, requirements.MemoryTypeBits, flags);
if (memoryTypeIndex < 0)
{
return(default);
private void CreateBuffer(ulong size, BufferUsageFlags usage, MemoryPropertyFlags properties, out Buffer buffer, out DeviceMemory bufferMemory)
{
buffer = device.CreateBuffer(size, usage, SharingMode.Exclusive, null);
var memRequirements = buffer.GetMemoryRequirements();
bufferMemory = device.AllocateMemory(memRequirements.Size, FindMemoryType(memRequirements.MemoryTypeBits, properties));
buffer.BindMemory(bufferMemory, 0);
}
uint FindMemoryIndex(MemoryPropertyFlags propertyFlags)
{
for (uint x = 0; x < VulkanConstant.MaxMemoryTypes; x++)
{
if ((physDeviceMem.MemoryTypes[x].PropertyFlags & propertyFlags) == propertyFlags)
{
return(x);
}
}
throw new InvalidOperationException();
}
internal uint FindMemoryTypeIndex(uint typeFilter, MemoryPropertyFlags properties)
{
for (uint i = 0; i < _physicalDeviceMemoryProperties.MemoryTypeCount; i++)
{
if (((typeFilter & 1) == 1) & ((_physicalDeviceMemoryProperties.MemoryTypes[(int)i].PropertyFlags & properties) == properties))
{
return(i);
}
}
throw new MissingMemberException("No compatible memory type found!");
}
protected virtual uint FindMemoryType(uint typeFilter, MemoryPropertyFlags properties)
{
var memProperties = data.physicalDevice.GetMemoryProperties();
for (uint i = 0; i < memProperties.MemoryTypeCount; i++)
{
if (((typeFilter >> (int)i) & 1) == 1 && (memProperties.MemoryTypes[i].PropertyFlags & properties) == properties)
{
return(i);
}
}
throw new Exception("Unable to find suiable memory type");
}
private uint FindMemoryType(uint typeFilter, MemoryPropertyFlags propertyFlags)
{
_api.Vk.GetPhysicalDeviceMemoryProperties(_api.Device.PhysicalDevice, out var memProperties);
for (int i = 0; i != memProperties.MemoryTypeCount; i++)
{
if ((typeFilter & (1 << i)) != 0 && (memProperties.MemoryTypes[i].PropertyFlags & propertyFlags) == propertyFlags)
{
return((uint)i);
}
}
throw new Exception($"{nameof(DeviceMemory)}: Unable to find suitable memory type.");
}
private uint FindMemoryType(uint typeFilter, MemoryPropertyFlags properties)
{
var memProperties = vkPhysicalDevice.GetMemoryProperties();
for (var i = 0; i < memProperties.MemoryTypeCount; ++i)
{
if ((typeFilter & (1 << i)) != 0 &&
(memProperties.MemoryTypes[i].PropertyFlags & properties) != 0)
{
return((uint)i);
}
}
throw new InvalidOperationException("Failed to find suitable memory type");
}
private uint FindMemoryType(uint typeFilter, MemoryPropertyFlags flags)
{
var memoryProperties = this.physicalDevice.GetMemoryProperties();
for (int i = 0; i < memoryProperties.MemoryTypes.Length; i++)
{
if ((typeFilter & (1u << i)) > 0 &&
memoryProperties.MemoryTypes[i].PropertyFlags.HasFlag(flags))
{
return((uint)i);
}
}
throw new Exception("No compatible memory type.");
}
internal static int FindSuitableMemoryTypeIndex(VulkanPhysicalDevice physicalDevice, uint memoryTypeBits,
MemoryPropertyFlags flags)
{
physicalDevice.Api.GetPhysicalDeviceMemoryProperties(physicalDevice.InternalHandle, out var properties);
for (var i = 0; i < properties.MemoryTypeCount; i++)
{
var type = properties.MemoryTypes[i];
if ((memoryTypeBits & (1 << i)) != 0 && type.PropertyFlags.HasFlag(flags))
{
return(i);
}
}
return(-1);
}
internal uint GetMemoryIndexFromProperty(uint memoryTypeBits, MemoryPropertyFlags deviceLocal)
{
var memoryProperties = this.GetMemoryProperties();//TODO: call once?
bool heapIndexSet = false;
var memoryTypes = memoryProperties.MemoryTypes;
for (uint i = 0; i < memoryProperties.MemoryTypeCount; i++)
{
if (((memoryTypeBits >> (int)i) & 1) == 1 &&
(memoryTypes[i].PropertyFlags & deviceLocal) == deviceLocal)
{
return(i);
}
}
return(memoryProperties.MemoryTypes[0].HeapIndex);
}
public AllocationCreateInfo(AllocationCreateFlags flags = default,
AllocationStrategyFlags strategy = default,
MemoryUsage usage = default,
MemoryPropertyFlags requiredFlags = default,
MemoryPropertyFlags preferredFlags = default,
uint memoryTypeBits = 0,
VulkanMemoryPool?pool = null,
object?userData = null)
{
Flags = flags;
Strategy = strategy;
Usage = usage;
RequiredFlags = requiredFlags;
PreferredFlags = preferredFlags;
MemoryTypeBits = memoryTypeBits;
Pool = pool;
UserData = userData;
}
public unsafe static DeviceMemory AllocateDeviceMemory(
Vk vk,
Device device,
PhysicalDevice physicalDevice,
MemoryRequirements requirements,
out long size,
MemoryPropertyFlags flags = 0,
bool isExternal = false)
{
_vk = vk;
size = 0;
int memoryTypeIndex = FindSuitableMemoryTypeIndex(physicalDevice, requirements.MemoryTypeBits, flags);
if (memoryTypeIndex < 0)
{
return(default);
static uint FindMemoryType(PhysicalDevice physicalDevice, uint typeFilter, MemoryPropertyFlags propertyFlags)
{
var memProperties = physicalDevice.GetMemoryProperties();
uint i = 0;
foreach (var memType in memProperties.MemoryTypes)
{
if ((((typeFilter >> (int)i) & 1) == 1) && ((memType.PropertyFlags & propertyFlags) == propertyFlags))
{
return(i);
}
i++;
}
MGlobal.displayError("failed to find memory type");
throw new Exception("failed to find memory type");
}
private void CreateBuffer(ulong size, BufferUsageFlags usage, MemoryPropertyFlags properties, out Buffer buffer, out DeviceMemory bufferMemory)
{
buffer = device.CreateBuffer(new BufferCreateInfo
{
Size = size,
Usage = usage,
SharingMode = SharingMode.Exclusive
});
var memRequirements = buffer.GetMemoryRequirements();
bufferMemory = device.AllocateMemory(new MemoryAllocateInfo
{
AllocationSize = memRequirements.Size,
MemoryTypeIndex = FindMemoryType(memRequirements.MemoryTypeBits, properties)
});
buffer.BindMemory(bufferMemory, 0);
}
protected unsafe void AllocateMemory(MemoryPropertyFlags memoryProperties)
{
MemoryRequirements memoryRequirements;
NativeDevice.GetBufferMemoryRequirements(nativeUploadBuffer, out memoryRequirements);
if (memoryRequirements.Size == 0)
{
return;
}
var allocateInfo = new MemoryAllocateInfo
{
StructureType = StructureType.MemoryAllocateInfo,
AllocationSize = memoryRequirements.Size,
};
PhysicalDeviceMemoryProperties physicalDeviceMemoryProperties;
NativePhysicalDevice.GetMemoryProperties(out 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 = *((MemoryType *)&physicalDeviceMemoryProperties.MemoryTypes + i);
if ((memoryType.PropertyFlags & memoryProperties) == memoryProperties)
{
allocateInfo.MemoryTypeIndex = i;
break;
}
}
typeBits >>= 1;
}
nativeUploadBufferMemory = NativeDevice.AllocateMemory(ref allocateInfo);
NativeDevice.BindBufferMemory(nativeUploadBuffer, nativeUploadBufferMemory, 0);
}
private uint MemoryTypeFromProperties(uint typeBits, MemoryPropertyFlags memoryProperties)
{
PhysicalDeviceMemoryProperties physicalDeviceMemoryProperties;
physicalDevice.GetMemoryProperties(out physicalDeviceMemoryProperties);
for (uint i = 0; i < physicalDeviceMemoryProperties.MemoryTypeCount; i++)
{
if ((typeBits & 1) == 1)
{
// Type is available, does it match user properties?
var memoryType = *((MemoryType *)&physicalDeviceMemoryProperties.MemoryTypes + i);
if ((memoryType.PropertyFlags & memoryProperties) == memoryProperties)
{
return(i);
}
}
typeBits >>= 1;
}
throw new InvalidOperationException();
}
public static uint GetMemoryTypeIndex(uint memoryTypeBits, MemoryPropertyFlags desiredMemoryFlags)
{
uint memoryTypeIndex = 0;
PhysicalDeviceMemoryProperties physicalDeviceMemoryProperties = VContext.Instance.physicalDevice.GetMemoryProperties();
for (uint i = 0; i < physicalDeviceMemoryProperties.MemoryTypeCount; i++)
{
if ((memoryTypeBits & 1) == 1)
{
MemoryType memoryType = physicalDeviceMemoryProperties.MemoryTypes[i];
if ((memoryType.PropertyFlags & desiredMemoryFlags) == desiredMemoryFlags)
{
memoryTypeIndex = i;
break;
}
}
memoryTypeBits >>= 1;
}
return(memoryTypeIndex);
}
private void CreateBuffer(DeviceSize size, BufferUsageFlags usageFlags, MemoryPropertyFlags properties, out Vulkan.Buffer buffer, out DeviceMemory bufferMemory)
{
var bufferInfo = new BufferCreateInfo()
{
Size = size,
Usage = usageFlags,
SharingMode = SharingMode.Exclusive,
};
buffer = vkDevice.CreateBuffer(bufferInfo);
var memRequirements = vkDevice.GetBufferMemoryRequirements(buffer);
var allocInfo = new MemoryAllocateInfo()
{
AllocationSize = memRequirements.Size,
MemoryTypeIndex = FindMemoryType(memRequirements.MemoryTypeBits, properties),
};
bufferMemory = vkDevice.AllocateMemory(allocInfo);
vkDevice.BindBufferMemory(buffer, bufferMemory, 0);
}
private void CreateImage(uint width, uint height, Format format, ImageTiling imageTiling, ImageUsageFlags usage, MemoryPropertyFlags properties, out Image image, out DeviceMemory imageMemory)
{
image = this.device.CreateImage(new ImageCreateInfo
{
ImageType = ImageType.Image2d,
Extent = new Extent3D
{
Width = width,
Height = height,
Depth = 1
},
ArrayLayers = 1,
MipLevels = 1,
Format = format,
Tiling = imageTiling,
InitialLayout = ImageLayout.Preinitialized,
Usage = usage,
SharingMode = SharingMode.Exclusive,
Samples = SampleCountFlags.SampleCount1,
Flags = ImageCreateFlags.None
});
var memoryRequirements = image.GetMemoryRequirements();
imageMemory = this.device.AllocateMemory(new MemoryAllocateInfo
{
AllocationSize = memoryRequirements.Size,
MemoryTypeIndex = this.FindMemoryType(memoryRequirements.MemoryTypeBits, properties)
});
image.BindMemory(imageMemory, 0);
}
public unsafe DeviceMemory(Api api, ulong size, uint memoryTypeBits, MemoryAllocateFlags allocateFlags, MemoryPropertyFlags propertyFlags)
{
_api = api;
var flagsInfo = new MemoryAllocateFlagsInfo();
flagsInfo.SType = StructureType.MemoryAllocateFlagsInfo;
flagsInfo.PNext = null;
flagsInfo.Flags = allocateFlags;
var allocInfo = new MemoryAllocateInfo();
allocInfo.SType = StructureType.MemoryAllocateInfo;
allocInfo.PNext = &flagsInfo;
allocInfo.AllocationSize = size;
allocInfo.MemoryTypeIndex = FindMemoryType(memoryTypeBits, propertyFlags);
Util.Verify(_api.Vk.AllocateMemory(_api.Device.VkDevice, allocInfo, null, out _vkDeviceMemory), $"{nameof(DeviceMemory)}: Unable to allocate memory.");
}
private uint MemoryTypeFromProperties(uint typeBits, MemoryPropertyFlags memoryProperties)
{
PhysicalDeviceMemoryProperties physicalDeviceMemoryProperties;
physicalDevice.GetMemoryProperties(out physicalDeviceMemoryProperties);
for (uint i = 0; i < physicalDeviceMemoryProperties.MemoryTypeCount; i++)
{
if ((typeBits & 1) == 1)
{
// Type is available, does it match user properties?
var memoryType = *((MemoryType*)&physicalDeviceMemoryProperties.MemoryTypes + i);
if ((memoryType.PropertyFlags & memoryProperties) == memoryProperties)
{
return i;
}
}
typeBits >>= 1;
}
throw new InvalidOperationException();
}
private void CreateImage(uint width, uint height, Format format, ImageTiling imageTiling, ImageUsageFlags usage, MemoryPropertyFlags properties, bool isPreinitialized, out Image image, out DeviceMemory imageMemory, out DeviceSize memoryOffset, out DeviceSize memorySize)
{
image = this.device.CreateImage(ImageType.Image2d, format, new Extent3D(width, height, 1), 1, 1, SampleCountFlags.SampleCount1, imageTiling, usage, this.queueIndices.Indices.Count() == 1 ? SharingMode.Exclusive : SharingMode.Concurrent, this.queueIndices.Indices.ToArray(), isPreinitialized ? ImageLayout.Preinitialized : ImageLayout.Undefined);
var memoryRequirements = image.GetMemoryRequirements();
memorySize = memoryRequirements.Size;
imageMemory = this.device.AllocateMemory(memorySize, this.FindMemoryType(memoryRequirements.MemoryTypeBits, properties));
memoryOffset = 0;
image.BindMemory(imageMemory, memoryOffset);
}
public VulkanBuffer CreateBuffer <T>(int count, BufferUsageFlags usage, MemoryPropertyFlags properties)
{
return(this.CreateBuffer((uint)(Marshal.SizeOf <T>() * count), usage, properties));
}
public VulkanBuffer CreateBuffer(ulong size, BufferUsageFlags usage, MemoryPropertyFlags properties)
{
this.CreateBuffer(size, usage, properties, out var buffer, out var _, out DeviceSize _);
return(new VulkanBuffer(this, buffer, size));
}
public VulkanImage CreateImage(uint width, uint height, Format format, ImageTiling imageTiling, ImageUsageFlags usage, MemoryPropertyFlags properties, bool isPreinitialized)
{
this.CreateImage(width, height, format, imageTiling, usage, properties, isPreinitialized, out var image, out var imageMemory, out DeviceSize offset, out DeviceSize size);
return(new VulkanImage(this, image, imageMemory, offset, size, format));
}
/// <summary>
///
/// </summary>
public MemoryType(MemoryPropertyFlags propertyFlags, uint heapIndex)
{
this.PropertyFlags = propertyFlags;
this.HeapIndex = heapIndex;
}
public VulkanImage CreateImage(uint width, uint height, Format format, ImageTiling imageTiling, ImageUsageFlags usage, MemoryPropertyFlags properties)
{
this.CreateImage(width, height, format, imageTiling, usage, properties, out var image, out var memory);
return(new VulkanImage(this, image, memory, format));
}
