public VkBuffer(VkGraphicsDevice gd, uint sizeInBytes, BufferUsage usage, string callerMember = null)
{
_gd = gd;
SizeInBytes = sizeInBytes;
Usage = usage;
VkBufferUsageFlags vkUsage = VkBufferUsageFlags.TransferSrc | VkBufferUsageFlags.TransferDst;
if ((usage & BufferUsage.VertexBuffer) == BufferUsage.VertexBuffer)
{
vkUsage |= VkBufferUsageFlags.VertexBuffer;
}
if ((usage & BufferUsage.IndexBuffer) == BufferUsage.IndexBuffer)
{
vkUsage |= VkBufferUsageFlags.IndexBuffer;
}
if ((usage & BufferUsage.UniformBuffer) == BufferUsage.UniformBuffer)
{
vkUsage |= VkBufferUsageFlags.UniformBuffer;
}
if ((usage & BufferUsage.StructuredBufferReadWrite) == BufferUsage.StructuredBufferReadWrite ||
(usage & BufferUsage.StructuredBufferReadOnly) == BufferUsage.StructuredBufferReadOnly)
{
vkUsage |= VkBufferUsageFlags.StorageBuffer;
}
if ((usage & BufferUsage.IndirectBuffer) == BufferUsage.IndirectBuffer)
{
vkUsage |= VkBufferUsageFlags.IndirectBuffer;
}
VkBufferCreateInfo bufferCI = VkBufferCreateInfo.New();
bufferCI.size = sizeInBytes;
bufferCI.usage = vkUsage;
VkResult result = vkCreateBuffer(gd.Device, ref bufferCI, null, out _deviceBuffer);
CheckResult(result);
bool prefersDedicatedAllocation;
if (_gd.GetBufferMemoryRequirements2 != null)
{
VkBufferMemoryRequirementsInfo2KHR memReqInfo2 = VkBufferMemoryRequirementsInfo2KHR.New();
memReqInfo2.buffer = _deviceBuffer;
VkMemoryRequirements2KHR memReqs2 = VkMemoryRequirements2KHR.New();
VkMemoryDedicatedRequirementsKHR dedicatedReqs = VkMemoryDedicatedRequirementsKHR.New();
memReqs2.pNext = &dedicatedReqs;
_gd.GetBufferMemoryRequirements2(_gd.Device, &memReqInfo2, &memReqs2);
_bufferMemoryRequirements = memReqs2.memoryRequirements;
prefersDedicatedAllocation = dedicatedReqs.prefersDedicatedAllocation || dedicatedReqs.requiresDedicatedAllocation;
}
else
{
vkGetBufferMemoryRequirements(gd.Device, _deviceBuffer, out _bufferMemoryRequirements);
prefersDedicatedAllocation = false;
}
bool hostVisible = (usage & BufferUsage.Dynamic) == BufferUsage.Dynamic ||
(usage & BufferUsage.Staging) == BufferUsage.Staging;
VkMemoryPropertyFlags memoryPropertyFlags =
hostVisible
? VkMemoryPropertyFlags.HostVisible | VkMemoryPropertyFlags.HostCoherent
: VkMemoryPropertyFlags.DeviceLocal;
VkMemoryBlock memoryToken = gd.MemoryManager.Allocate(
gd.PhysicalDeviceMemProperties,
_bufferMemoryRequirements.memoryTypeBits,
memoryPropertyFlags,
hostVisible,
_bufferMemoryRequirements.size,
_bufferMemoryRequirements.alignment,
prefersDedicatedAllocation,
VkImage.Null,
_deviceBuffer);
_memory = memoryToken;
result = vkBindBufferMemory(gd.Device, _deviceBuffer, _memory.DeviceMemory, _memory.Offset);
CheckResult(result);
RefCount = new ResourceRefCount(DisposeCore);
}
internal VkTexture(VkGraphicsDevice gd, ref TextureDescription description)
{
_gd = gd;
_width = description.Width;
_height = description.Height;
_depth = description.Depth;
MipLevels = description.MipLevels;
ArrayLayers = description.ArrayLayers;
bool isCubemap = ((description.Usage) & TextureUsage.Cubemap) == TextureUsage.Cubemap;
_actualImageArrayLayers = isCubemap
? 6 * ArrayLayers
: ArrayLayers;
_format = description.Format;
Usage = description.Usage;
Type = description.Type;
SampleCount = description.SampleCount;
VkSampleCount = VkFormats.VdToVkSampleCount(SampleCount);
VkFormat = VkFormats.VdToVkPixelFormat(Format, (description.Usage & TextureUsage.DepthStencil) == TextureUsage.DepthStencil);
bool isStaging = (Usage & TextureUsage.Staging) == TextureUsage.Staging;
if (!isStaging)
{
VkImageCreateInfo imageCI = VkImageCreateInfo.New();
imageCI.mipLevels = MipLevels;
imageCI.arrayLayers = _actualImageArrayLayers;
imageCI.imageType = VkFormats.VdToVkTextureType(Type);
imageCI.extent.width = Width;
imageCI.extent.height = Height;
imageCI.extent.depth = Depth;
imageCI.initialLayout = VkImageLayout.Preinitialized;
imageCI.usage = VkFormats.VdToVkTextureUsage(Usage);
imageCI.tiling = isStaging ? VkImageTiling.Linear : VkImageTiling.Optimal;
imageCI.format = VkFormat;
imageCI.flags = VkImageCreateFlags.MutableFormat;
imageCI.samples = VkSampleCount;
if (isCubemap)
{
imageCI.flags |= VkImageCreateFlags.CubeCompatible;
}
uint subresourceCount = MipLevels * _actualImageArrayLayers * Depth;
VkResult result = vkCreateImage(gd.Device, ref imageCI, null, out _optimalImage);
CheckResult(result);
VkMemoryRequirements memoryRequirements;
bool prefersDedicatedAllocation;
if (_gd.GetImageMemoryRequirements2 != null)
{
VkImageMemoryRequirementsInfo2KHR memReqsInfo2 = VkImageMemoryRequirementsInfo2KHR.New();
memReqsInfo2.image = _optimalImage;
VkMemoryRequirements2KHR memReqs2 = VkMemoryRequirements2KHR.New();
VkMemoryDedicatedRequirementsKHR dedicatedReqs = VkMemoryDedicatedRequirementsKHR.New();
memReqs2.pNext = &dedicatedReqs;
_gd.GetImageMemoryRequirements2(_gd.Device, &memReqsInfo2, &memReqs2);
memoryRequirements = memReqs2.memoryRequirements;
prefersDedicatedAllocation = dedicatedReqs.prefersDedicatedAllocation || dedicatedReqs.requiresDedicatedAllocation;
}
else
{
vkGetImageMemoryRequirements(gd.Device, _optimalImage, out memoryRequirements);
prefersDedicatedAllocation = false;
}
VkMemoryBlock memoryToken = gd.MemoryManager.Allocate(
gd.PhysicalDeviceMemProperties,
memoryRequirements.memoryTypeBits,
VkMemoryPropertyFlags.DeviceLocal,
false,
memoryRequirements.size,
memoryRequirements.alignment,
prefersDedicatedAllocation,
_optimalImage,
Vulkan.VkBuffer.Null);
_memoryBlock = memoryToken;
result = vkBindImageMemory(gd.Device, _optimalImage, _memoryBlock.DeviceMemory, _memoryBlock.Offset);
CheckResult(result);
_imageLayouts = new VkImageLayout[subresourceCount];
for (int i = 0; i < _imageLayouts.Length; i++)
{
_imageLayouts[i] = VkImageLayout.Preinitialized;
}
}
else // isStaging
{
uint depthPitch = FormatHelpers.GetDepthPitch(
FormatHelpers.GetRowPitch(Width, Format),
Height,
Format);
uint stagingSize = depthPitch * Depth;
for (uint level = 1; level < MipLevels; level++)
{
Util.GetMipDimensions(this, level, out uint mipWidth, out uint mipHeight, out uint mipDepth);
depthPitch = FormatHelpers.GetDepthPitch(
FormatHelpers.GetRowPitch(mipWidth, Format),
mipHeight,
Format);
stagingSize += depthPitch * mipDepth;
}
stagingSize *= ArrayLayers;
VkBufferCreateInfo bufferCI = VkBufferCreateInfo.New();
bufferCI.usage = VkBufferUsageFlags.TransferSrc | VkBufferUsageFlags.TransferDst;
bufferCI.size = stagingSize;
VkResult result = vkCreateBuffer(_gd.Device, ref bufferCI, null, out _stagingBuffer);
CheckResult(result);
VkMemoryRequirements bufferMemReqs;
bool prefersDedicatedAllocation;
if (_gd.GetBufferMemoryRequirements2 != null)
{
VkBufferMemoryRequirementsInfo2KHR memReqInfo2 = VkBufferMemoryRequirementsInfo2KHR.New();
memReqInfo2.buffer = _stagingBuffer;
VkMemoryRequirements2KHR memReqs2 = VkMemoryRequirements2KHR.New();
VkMemoryDedicatedRequirementsKHR dedicatedReqs = VkMemoryDedicatedRequirementsKHR.New();
memReqs2.pNext = &dedicatedReqs;
_gd.GetBufferMemoryRequirements2(_gd.Device, &memReqInfo2, &memReqs2);
bufferMemReqs = memReqs2.memoryRequirements;
prefersDedicatedAllocation = dedicatedReqs.prefersDedicatedAllocation || dedicatedReqs.requiresDedicatedAllocation;
}
else
{
vkGetBufferMemoryRequirements(gd.Device, _stagingBuffer, out bufferMemReqs);
prefersDedicatedAllocation = false;
}
_memoryBlock = _gd.MemoryManager.Allocate(
_gd.PhysicalDeviceMemProperties,
bufferMemReqs.memoryTypeBits,
VkMemoryPropertyFlags.HostVisible | VkMemoryPropertyFlags.HostCoherent,
true,
bufferMemReqs.size,
bufferMemReqs.alignment,
prefersDedicatedAllocation,
VkImage.Null,
_stagingBuffer);
result = vkBindBufferMemory(_gd.Device, _stagingBuffer, _memoryBlock.DeviceMemory, _memoryBlock.Offset);
CheckResult(result);
}
ClearIfRenderTarget();
TransitionIfSampled();
RefCount = new ResourceRefCount(RefCountedDispose);
}