void GetMemoryProperties()
{
using (var prop = new Marshalled <VkPhysicalDeviceMemoryProperties>()) {
Instance.Commands.getMemoryProperties(physicalDevice, prop.Address);
memoryProperties = prop.Value;
}
}
public static VkMemoryType GetMemoryType(this VkPhysicalDeviceMemoryProperties memoryProperties, uint index)
{
//return (&memoryProperties.memoryTypes_0)[index];
var types = (VkMemoryType *)memoryProperties.memoryTypes;
return(types[index]);
}
public SoftwarePhysicalDevice(SoftwareInstance instance)
{
m_Instance = instance;
m_QueueFamilyProperties.Add(VkQueueFamilyProperties.Create(1, VkQueueFlagBits.VK_QUEUE_GRAPHICS_BIT));
m_QueueFamilyProperties.Add(VkQueueFamilyProperties.Create(1, VkQueueFlagBits.VK_QUEUE_COMPUTE_BIT));
m_ExtensionProperties.Add(VkExtensionProperties.Create(VkExtensionNames.VK_KHR_SWAPCHAIN_EXTENSION_NAME, 1));
m_PhysicalDeviceMemoryProperties = new VkPhysicalDeviceMemoryProperties();
m_PhysicalDeviceMemoryProperties.memoryTypeCount = 1;
m_PhysicalDeviceMemoryProperties.memoryTypes = new VkMemoryType[]
{
new VkMemoryType()
{
heapIndex = 0,
propertyFlags = VkMemoryPropertyFlagBits.VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT | VkMemoryPropertyFlagBits.VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT | VkMemoryPropertyFlagBits.VK_MEMORY_PROPERTY_HOST_COHERENT_BIT
}
};
m_PhysicalDeviceMemoryProperties.memoryHeapCount = 1;
m_PhysicalDeviceMemoryProperties.memoryHeaps = new VkMemoryHeap[]
{
new VkMemoryHeap()
{
flags = VkMemoryHeapFlagBits.VK_MEMORY_HEAP_DEVICE_LOCAL_BIT, size = 64 * 1024 * 1024
}
};
}
internal void CreateMemoryProperties()
{
VkPhysicalDeviceMemoryProperties memoryProperties;
vkGetPhysicalDeviceMemoryProperties(NativeAdapter.NativePhysicalDevice, out memoryProperties);
MemoryProperties = memoryProperties;
}
public VkMemoryBlock Allocate(
VkPhysicalDeviceMemoryProperties memProperties,
uint memoryTypeBits,
VkMemoryPropertyFlags flags,
bool persistentMapped,
ulong size,
ulong alignment)
{
lock (_lock)
{
uint memoryTypeIndex = FindMemoryType(memProperties, memoryTypeBits, flags);
ulong minDedicatedAllocationSize = persistentMapped
? MinDedicatedAllocationSizeDynamic
: MinDedicatedAllocationSizeNonDynamic;
if (size >= minDedicatedAllocationSize)
{
VkMemoryAllocateInfo allocateInfo = VkMemoryAllocateInfo.New();
allocateInfo.allocationSize = size;
allocateInfo.memoryTypeIndex = memoryTypeIndex;
VkResult allocationResult = vkAllocateMemory(_device, ref allocateInfo, null, out VkDeviceMemory memory);
if (allocationResult != VkResult.Success)
{
throw new VeldridException("Unable to allocate sufficient Vulkan memory.");
}
void *mappedPtr = null;
if (persistentMapped)
{
VkResult mapResult = vkMapMemory(_device, memory, 0, size, 0, &mappedPtr);
if (mapResult != VkResult.Success)
{
throw new VeldridException("Unable to map newly-allocated Vulkan memory.");
}
}
return(new VkMemoryBlock(memory, 0, size, memoryTypeBits, null, true));
}
else
{
ChunkAllocatorSet allocator = GetAllocator(memoryTypeIndex, persistentMapped);
bool result = allocator.Allocate(size, alignment, out VkMemoryBlock ret);
if (!result)
{
throw new VeldridException("Unable to allocate sufficient Vulkan memory.");
}
return(ret);
}
}
}
public ResourceManager(Device dev, ulong defaultPoolsBlockDivisor = 4)
{
memoryProperties = dev.phy.memoryProperties;
memoryPools = new MemoryPool[memoryProperties.memoryTypeCount];
reservedHeapMemory = new ulong[memoryProperties.memoryHeapCount];
for (uint i = 0; i < memoryPools.Length; i++)
{
ulong size = getHeapFromMemoryIndex(i).size / defaultPoolsBlockDivisor;
memoryPools[i] = new MemoryPool(dev, i, size);
reservedHeapMemory[memoryProperties.memoryTypes[i].heapIndex] += size;
}
}
public static uint FindMemoryType(VkPhysicalDeviceMemoryProperties memProperties, uint typeFilter, VkMemoryPropertyFlags properties)
{
for (int i = 0; i < memProperties.memoryTypeCount; i++)
{
if (((typeFilter & (1 << i)) != 0) &&
(memProperties.GetMemoryType((uint)i).propertyFlags & properties) == properties)
{
return((uint)i);
}
}
throw new VeldridException("No suitable memory type.");
}
public static bool TryFindMemoryType(VkPhysicalDeviceMemoryProperties memProperties, uint typeFilter, VkMemoryPropertyFlags properties, out uint typeIndex)
{
typeIndex = 0;
for (int i = 0; i < memProperties.memoryTypeCount; i++)
{
if (((typeFilter & (1 << i)) != 0) &&
(memProperties.GetMemoryType((uint)i).propertyFlags & properties) == properties)
{
typeIndex = (uint)i;
return(true);
}
}
return(false);
}
public static uint IndexOf(this VkPhysicalDeviceMemoryProperties memoryProperties, int memoryTypeBits, VkMemoryPropertyFlags properties)
{
uint count = memoryProperties.memoryTypeCount;
for (uint i = 0; i < count; i++)
{
if ((memoryTypeBits & 1) == 1 &&
((&memoryProperties.memoryTypes_0)[i].propertyFlags & properties) == properties)
{
return(i);
}
memoryTypeBits >>= 1;
}
return(uint.MaxValue);
}
public static void CreateImage(
VkDevice device,
VkPhysicalDeviceMemoryProperties physicalDeviceMemProperties,
VkDeviceMemoryManager memoryManager,
uint width,
uint height,
uint depth,
uint arrayLayers,
VkFormat format,
VkImageTiling tiling,
VkImageUsageFlags usage,
VkMemoryPropertyFlags properties,
out VkImage image,
out VkMemoryBlock memory)
{
VkImageCreateInfo imageCI = VkImageCreateInfo.New();
imageCI.imageType = VkImageType.Image2D;
imageCI.extent.width = width;
imageCI.extent.height = height;
imageCI.extent.depth = depth;
imageCI.mipLevels = 1;
imageCI.arrayLayers = arrayLayers;
imageCI.format = format;
imageCI.tiling = tiling;
imageCI.initialLayout = VkImageLayout.Preinitialized;
imageCI.usage = usage;
imageCI.sharingMode = VkSharingMode.Exclusive;
imageCI.samples = VkSampleCountFlags.Count1;
VkResult result = vkCreateImage(device, ref imageCI, null, out image);
CheckResult(result);
vkGetImageMemoryRequirements(device, image, out VkMemoryRequirements memRequirements);
VkMemoryBlock memoryToken = memoryManager.Allocate(
physicalDeviceMemProperties,
memRequirements.memoryTypeBits,
properties,
false,
memRequirements.size,
memRequirements.alignment);
memory = memoryToken;
result = vkBindImageMemory(device, image, memory.DeviceMemory, memory.Offset);
CheckResult(result);
}
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 VkMemoryBlock Allocate(
VkPhysicalDeviceMemoryProperties memProperties,
uint memoryTypeBits,
VkMemoryPropertyFlags flags,
bool persistentMapped,
ulong size,
ulong alignment)
{
return(Allocate(
memProperties,
memoryTypeBits,
flags,
persistentMapped,
size,
alignment,
false,
VkImage.Null,
Vulkan.VkBuffer.Null));
}
public VkMemoryBlock Allocate(
VkPhysicalDeviceMemoryProperties memProperties,
uint memoryTypeBits,
VkMemoryPropertyFlags flags,
bool persistentMapped,
ulong size,
ulong alignment)
{
lock (_lock)
{
uint memoryTypeIndex = FindMemoryType(memProperties, memoryTypeBits, flags);
ChunkAllocatorSet allocator = GetAllocator(memoryTypeIndex, persistentMapped);
bool result = allocator.Allocate(size, alignment, out VkMemoryBlock ret);
if (!result)
{
throw new VeldridException("Unable to allocate memory.");
}
return(ret);
}
}
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;
}
//VkMemoryPropertyFlagBits.VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT
private uint GetMemoryTypeIndex(VkPhysicalDeviceMemoryProperties memoryProperties, VkMemoryRequirements memoryReq, VkMemoryPropertyFlagBits flags)
{
uint result = 0;
bool heapIndexSet = false;
VkMemoryType *memoryTypes = (VkMemoryType *)memoryProperties.memoryTypes;
for (uint i = 0; i < memoryProperties.memoryTypeCount; i++)
{
if (((memoryReq.memoryTypeBits >> (int)i) & 1) == 1 &&
(memoryTypes[i].propertyFlags & flags) == flags)
{
result = i;
heapIndexSet = true;
break;
}
}
if (!heapIndexSet)
{
result = memoryTypes[0].heapIndex;
}
return(result);
}
internal VkMemoryType GetMemoryType(VkPhysicalDeviceMemoryProperties memoryProperties, uint index)
{
return((&memoryProperties.memoryTypes_0)[index]);
}
public VkMemoryBlock Allocate(
VkPhysicalDeviceMemoryProperties memProperties,
uint memoryTypeBits,
VkMemoryPropertyFlags flags,
bool persistentMapped,
ulong size,
ulong alignment,
bool dedicated,
VkImage dedicatedImage,
Vulkan.VkBuffer dedicatedBuffer)
{
// Round up to the nearest multiple of bufferImageGranularity.
size = ((size / _bufferImageGranularity) + 1) * _bufferImageGranularity;
_totalAllocatedBytes += size;
lock (_lock)
{
if (!TryFindMemoryType(memProperties, memoryTypeBits, flags, out var memoryTypeIndex))
{
throw new VeldridException("No suitable memory type.");
}
ulong minDedicatedAllocationSize = persistentMapped
? MinDedicatedAllocationSizeDynamic
: MinDedicatedAllocationSizeNonDynamic;
if (dedicated || size >= minDedicatedAllocationSize)
{
VkMemoryAllocateInfo allocateInfo = VkMemoryAllocateInfo.New();
allocateInfo.allocationSize = size;
allocateInfo.memoryTypeIndex = memoryTypeIndex;
VkMemoryDedicatedAllocateInfoKHR dedicatedAI;
if (dedicated)
{
dedicatedAI = VkMemoryDedicatedAllocateInfoKHR.New();
dedicatedAI.buffer = dedicatedBuffer;
dedicatedAI.image = dedicatedImage;
allocateInfo.pNext = &dedicatedAI;
}
VkResult allocationResult = vkAllocateMemory(_device, ref allocateInfo, null, out VkDeviceMemory memory);
if (allocationResult != VkResult.Success)
{
throw new VeldridException("Unable to allocate sufficient Vulkan memory.");
}
void *mappedPtr = null;
if (persistentMapped)
{
VkResult mapResult = vkMapMemory(_device, memory, 0, size, 0, &mappedPtr);
if (mapResult != VkResult.Success)
{
throw new VeldridException("Unable to map newly-allocated Vulkan memory.");
}
}
return(new VkMemoryBlock(memory, 0, size, memoryTypeBits, mappedPtr, true));
}
else
{
ChunkAllocatorSet allocator = GetAllocator(memoryTypeIndex, persistentMapped);
bool result = allocator.Allocate(size, alignment, out VkMemoryBlock ret);
if (!result)
{
throw new VeldridException("Unable to allocate sufficient Vulkan memory.");
}
return(ret);
}
}
}
public static VkMemoryType GetMemoryType(this VkPhysicalDeviceMemoryProperties memoryProperties, uint index)
{
return((&memoryProperties.memoryTypes_0)[index]);
}
public static uint GetMemoryTypeIndex(uint typeBits, VkMemoryPropertyFlags properties, VkPhysicalDeviceMemoryProperties memoryProperties)
{
// Iterate over all memory types available for the Device used in this example
for (uint i = 0; i < memoryProperties.memoryTypeCount; i++)
{
if ((typeBits & 1) == 1)
{
if ((memoryProperties.GetMemoryType(i).propertyFlags & properties) == properties)
{
return(i);
}
}
typeBits >>= 1;
}
throw new InvalidOperationException("Could not find a suitable memory type!");
}
private static VkImage LoadTexture(VkDevice device, VkPhysicalDevice physicalDevice, int cmdPoolID, VkQueue queue, string[] paths, uint mipLevels)
{
Bitmap[] bitmaps = new Bitmap[paths.Length];
FDataBuffer <byte>[] tempBuffer = new FDataBuffer <byte> [paths.Length];
uint width = 0, height = 0;
for (int j = 0; j < paths.Length; j++)
{
bitmaps[j] = new Bitmap(System.Drawing.Image.FromFile(paths[j]));
var data = bitmaps[j].LockBits(new Rectangle(0, 0, bitmaps[j].Width, bitmaps[j].Height), System.Drawing.Imaging.ImageLockMode.ReadOnly,
bitmaps[j].PixelFormat);
width = (uint)data.Width;
height = (uint)data.Height;//TODO add size check
Span <byte> img = new Span <byte>((void *)data.Scan0, data.Stride * data.Height);
tempBuffer[j] = new FDataBuffer <byte>(device, physicalDevice, img.Length, VkBufferUsageFlags.TransferSrc,
VkSharingMode.Exclusive);
Span <byte> buffer = tempBuffer[j].Map();
for (int i = 0; i < img.Length; i += 4)
{
buffer[i + 2] = img[i];
buffer[i + 1] = img[i + 1];
buffer[i] = img[i + 2];
buffer[i + 3] = img[i + 3];
}
buffer = tempBuffer[j].UnMap();
}
VkImage texture = VkImage.Null;
VkDeviceMemory memory = VkDeviceMemory.Null;
VkImageCreateInfo createInfo = VkImageCreateInfo.New();
createInfo.imageType = VkImageType.Image2D;
createInfo.extent.width = width;
createInfo.extent.height = height;
createInfo.extent.depth = 1;
createInfo.mipLevels = mipLevels;
createInfo.arrayLayers = (uint)paths.Length;
createInfo.format = VkFormat.R8g8b8a8Unorm;
createInfo.tiling = VkImageTiling.Optimal;
createInfo.initialLayout = VkImageLayout.Undefined;
createInfo.usage = VkImageUsageFlags.TransferDst | VkImageUsageFlags.Sampled | VkImageUsageFlags.TransferSrc;
createInfo.sharingMode = VkSharingMode.Exclusive;
createInfo.samples = VkSampleCountFlags.Count1;
Assert(vkCreateImage(device, &createInfo, null, &texture));
VkMemoryRequirements memoryRequirements;
vkGetImageMemoryRequirements(device, texture, &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);
Assert(vkAllocateMemory(device, &allocateInfo, null, &memory));
vkBindImageMemory(device, texture, memory, 0);
VkCommandBufferAllocateInfo pAllocateInfo = VkCommandBufferAllocateInfo.New();
pAllocateInfo.commandPool = CommandPoolManager.GetPool(cmdPoolID);
pAllocateInfo.level = VkCommandBufferLevel.Primary;
pAllocateInfo.commandBufferCount = 1;
VkCommandBuffer cmdBuffer = VkCommandBuffer.Null;
Assert(vkAllocateCommandBuffers(device, &pAllocateInfo, &cmdBuffer));
VkCommandBufferBeginInfo beginInfo = VkCommandBufferBeginInfo.New();
beginInfo.flags = VkCommandBufferUsageFlags.OneTimeSubmit;
Assert(vkBeginCommandBuffer(cmdBuffer, &beginInfo));
VkImageMemoryBarrier imageMemoryBarrier = VkImageMemoryBarrier.New();
imageMemoryBarrier.srcAccessMask = VkAccessFlags.None;
imageMemoryBarrier.dstAccessMask = VkAccessFlags.ColorAttachmentRead | VkAccessFlags.ColorAttachmentWrite;
imageMemoryBarrier.oldLayout = VkImageLayout.Undefined;
imageMemoryBarrier.newLayout = VkImageLayout.TransferDstOptimal;
imageMemoryBarrier.srcQueueFamilyIndex = VulkanNative.QueueFamilyIgnored;
imageMemoryBarrier.dstQueueFamilyIndex = VulkanNative.QueueFamilyIgnored;
imageMemoryBarrier.image = texture;
imageMemoryBarrier.subresourceRange = new VkImageSubresourceRange()
{
baseMipLevel = 0,
levelCount = mipLevels,
baseArrayLayer = 0,
layerCount = (uint)paths.Length,
aspectMask = VkImageAspectFlags.Color
};
vkCmdPipelineBarrier(cmdBuffer, VkPipelineStageFlags.AllCommands, VkPipelineStageFlags.AllCommands, VkDependencyFlags.ByRegion,
0, null, 0, null, 1, &imageMemoryBarrier);
for (int j = 0; j < tempBuffer.Length; j++)
{
VkBufferImageCopy region = new VkBufferImageCopy();
region.bufferOffset = 0;
region.bufferRowLength = 0;
region.bufferImageHeight = 0;
region.imageSubresource.aspectMask = VkImageAspectFlags.Color;
region.imageSubresource.mipLevel = 0;
region.imageSubresource.baseArrayLayer = (uint)j;
region.imageSubresource.layerCount = 1;
region.imageOffset = new VkOffset3D();
region.imageExtent = new VkExtent3D()
{
width = width, height = height, depth = 1
};
vkCmdCopyBufferToImage(cmdBuffer, tempBuffer[j].Buffer, texture, VkImageLayout.TransferDstOptimal, 1, ®ion);
}
imageMemoryBarrier.oldLayout = VkImageLayout.TransferDstOptimal;
imageMemoryBarrier.newLayout = VkImageLayout.ShaderReadOnlyOptimal;
vkCmdPipelineBarrier(cmdBuffer, VkPipelineStageFlags.AllCommands, VkPipelineStageFlags.AllCommands, VkDependencyFlags.ByRegion,
0, null, 0, null, 1, &imageMemoryBarrier);
Assert(vkEndCommandBuffer(cmdBuffer));
VkSubmitInfo submitInfo = VkSubmitInfo.New();
submitInfo.commandBufferCount = 1;
submitInfo.pCommandBuffers = &cmdBuffer;
Assert(vkQueueSubmit(queue, 1, &submitInfo, VkFence.Null));
Assert(vkQueueWaitIdle(queue));
vkFreeCommandBuffers(device, CommandPoolManager.GetPool(cmdPoolID), 1, &cmdBuffer);
return(texture);
}
public static VkMemoryType GetMemoryType(
VkPhysicalDeviceMemoryProperties memoryProperties,
uint i
)
{
switch (i)
{
case 0:
return(memoryProperties.memoryTypes_0);
case 1:
return(memoryProperties.memoryTypes_1);
case 2:
return(memoryProperties.memoryTypes_2);
case 3:
return(memoryProperties.memoryTypes_3);
case 4:
return(memoryProperties.memoryTypes_4);
case 5:
return(memoryProperties.memoryTypes_5);
case 6:
return(memoryProperties.memoryTypes_6);
case 7:
return(memoryProperties.memoryTypes_7);
case 8:
return(memoryProperties.memoryTypes_8);
case 9:
return(memoryProperties.memoryTypes_9);
case 10:
return(memoryProperties.memoryTypes_10);
case 11:
return(memoryProperties.memoryTypes_11);
case 12:
return(memoryProperties.memoryTypes_12);
case 13:
return(memoryProperties.memoryTypes_13);
case 14:
return(memoryProperties.memoryTypes_14);
case 15:
return(memoryProperties.memoryTypes_15);
case 16:
return(memoryProperties.memoryTypes_16);
case 17:
return(memoryProperties.memoryTypes_17);
case 18:
return(memoryProperties.memoryTypes_18);
case 19:
return(memoryProperties.memoryTypes_19);
case 20:
return(memoryProperties.memoryTypes_20);
case 21:
return(memoryProperties.memoryTypes_21);
case 22:
return(memoryProperties.memoryTypes_22);
case 23:
return(memoryProperties.memoryTypes_23);
case 24:
return(memoryProperties.memoryTypes_24);
case 25:
return(memoryProperties.memoryTypes_25);
case 26:
return(memoryProperties.memoryTypes_26);
case 27:
return(memoryProperties.memoryTypes_27);
case 28:
return(memoryProperties.memoryTypes_28);
case 29:
return(memoryProperties.memoryTypes_29);
case 30:
return(memoryProperties.memoryTypes_30);
case 31:
return(memoryProperties.memoryTypes_31);
default:
throw new NotSupportedException("this type of memory is not supported");
}
}
public virtual void GetMemoryProperties(out VkPhysicalDeviceMemoryProperties pMemoryProperties)
{
pMemoryProperties = m_PhysicalDeviceMemoryProperties;
}
