mirror of
https://github.com/Ryujinx/Ryujinx.git
synced 2024-08-20 15:48:43 +02:00
* Relax Vulkan requirements * Fix MaxColorAttachmentIndex * Fix ColorBlendAttachmentStateCount value mismatch for background pipelines * Change query capability check to check for pipeline statistics query rather than geometry shader support
394 lines
14 KiB
C#
394 lines
14 KiB
C#
using Ryujinx.Graphics.GAL;
|
|
using Silk.NET.Vulkan;
|
|
using System;
|
|
using System.Runtime.CompilerServices;
|
|
using System.Runtime.InteropServices;
|
|
using VkFormat = Silk.NET.Vulkan.Format;
|
|
|
|
namespace Ryujinx.Graphics.Vulkan
|
|
{
|
|
class BufferManager : IDisposable
|
|
{
|
|
private const MemoryPropertyFlags DefaultBufferMemoryFlags =
|
|
MemoryPropertyFlags.HostVisibleBit |
|
|
MemoryPropertyFlags.HostCoherentBit |
|
|
MemoryPropertyFlags.HostCachedBit;
|
|
|
|
// Some drivers don't expose a "HostCached" memory type,
|
|
// so we need those alternative flags for the allocation to succeed there.
|
|
private const MemoryPropertyFlags DefaultBufferMemoryAltFlags =
|
|
MemoryPropertyFlags.HostVisibleBit |
|
|
MemoryPropertyFlags.HostCoherentBit;
|
|
|
|
private const MemoryPropertyFlags DeviceLocalBufferMemoryFlags =
|
|
MemoryPropertyFlags.DeviceLocalBit;
|
|
|
|
private const MemoryPropertyFlags FlushableDeviceLocalBufferMemoryFlags =
|
|
MemoryPropertyFlags.HostVisibleBit |
|
|
MemoryPropertyFlags.HostCoherentBit |
|
|
MemoryPropertyFlags.DeviceLocalBit;
|
|
|
|
private const BufferUsageFlags DefaultBufferUsageFlags =
|
|
BufferUsageFlags.TransferSrcBit |
|
|
BufferUsageFlags.TransferDstBit |
|
|
BufferUsageFlags.UniformTexelBufferBit |
|
|
BufferUsageFlags.StorageTexelBufferBit |
|
|
BufferUsageFlags.UniformBufferBit |
|
|
BufferUsageFlags.StorageBufferBit |
|
|
BufferUsageFlags.IndexBufferBit |
|
|
BufferUsageFlags.VertexBufferBit |
|
|
BufferUsageFlags.TransformFeedbackBufferBitExt;
|
|
|
|
private readonly PhysicalDevice _physicalDevice;
|
|
private readonly Device _device;
|
|
|
|
private readonly IdList<BufferHolder> _buffers;
|
|
|
|
public int BufferCount { get; private set; }
|
|
|
|
public StagingBuffer StagingBuffer { get; }
|
|
|
|
public BufferManager(VulkanRenderer gd, PhysicalDevice physicalDevice, Device device)
|
|
{
|
|
_physicalDevice = physicalDevice;
|
|
_device = device;
|
|
_buffers = new IdList<BufferHolder>();
|
|
StagingBuffer = new StagingBuffer(gd, this);
|
|
}
|
|
|
|
public BufferHandle CreateWithHandle(VulkanRenderer gd, int size, bool deviceLocal)
|
|
{
|
|
return CreateWithHandle(gd, size, deviceLocal, out _);
|
|
}
|
|
|
|
public BufferHandle CreateWithHandle(VulkanRenderer gd, int size, bool deviceLocal, out BufferHolder holder)
|
|
{
|
|
holder = Create(gd, size, deviceLocal: deviceLocal);
|
|
if (holder == null)
|
|
{
|
|
return BufferHandle.Null;
|
|
}
|
|
|
|
BufferCount++;
|
|
|
|
ulong handle64 = (uint)_buffers.Add(holder);
|
|
|
|
return Unsafe.As<ulong, BufferHandle>(ref handle64);
|
|
}
|
|
|
|
public unsafe BufferHolder Create(VulkanRenderer gd, int size, bool forConditionalRendering = false, bool deviceLocal = false)
|
|
{
|
|
var usage = DefaultBufferUsageFlags;
|
|
|
|
if (forConditionalRendering && gd.Capabilities.SupportsConditionalRendering)
|
|
{
|
|
usage |= BufferUsageFlags.ConditionalRenderingBitExt;
|
|
}
|
|
else if (gd.Capabilities.SupportsIndirectParameters)
|
|
{
|
|
usage |= BufferUsageFlags.IndirectBufferBit;
|
|
}
|
|
|
|
var bufferCreateInfo = new BufferCreateInfo()
|
|
{
|
|
SType = StructureType.BufferCreateInfo,
|
|
Size = (ulong)size,
|
|
Usage = usage,
|
|
SharingMode = SharingMode.Exclusive
|
|
};
|
|
|
|
gd.Api.CreateBuffer(_device, in bufferCreateInfo, null, out var buffer).ThrowOnError();
|
|
gd.Api.GetBufferMemoryRequirements(_device, buffer, out var requirements);
|
|
|
|
MemoryPropertyFlags allocateFlags;
|
|
MemoryPropertyFlags allocateFlagsAlt;
|
|
|
|
if (deviceLocal)
|
|
{
|
|
allocateFlags = DeviceLocalBufferMemoryFlags;
|
|
allocateFlagsAlt = DeviceLocalBufferMemoryFlags;
|
|
}
|
|
else
|
|
{
|
|
allocateFlags = DefaultBufferMemoryFlags;
|
|
allocateFlagsAlt = DefaultBufferMemoryAltFlags;
|
|
}
|
|
|
|
var allocation = gd.MemoryAllocator.AllocateDeviceMemory(_physicalDevice, requirements, allocateFlags, allocateFlagsAlt);
|
|
|
|
if (allocation.Memory.Handle == 0UL)
|
|
{
|
|
gd.Api.DestroyBuffer(_device, buffer, null);
|
|
return null;
|
|
}
|
|
|
|
gd.Api.BindBufferMemory(_device, buffer, allocation.Memory, allocation.Offset);
|
|
|
|
return new BufferHolder(gd, _device, buffer, allocation, size);
|
|
}
|
|
|
|
public Auto<DisposableBufferView> CreateView(BufferHandle handle, VkFormat format, int offset, int size)
|
|
{
|
|
if (TryGetBuffer(handle, out var holder))
|
|
{
|
|
return holder.CreateView(format, offset, size);
|
|
}
|
|
|
|
return null;
|
|
}
|
|
|
|
public Auto<DisposableBuffer> GetBuffer(CommandBuffer commandBuffer, BufferHandle handle, bool isWrite)
|
|
{
|
|
if (TryGetBuffer(handle, out var holder))
|
|
{
|
|
return holder.GetBuffer(commandBuffer, isWrite);
|
|
}
|
|
|
|
return null;
|
|
}
|
|
|
|
public Auto<DisposableBuffer> GetBuffer(CommandBuffer commandBuffer, BufferHandle handle, int offset, int size, bool isWrite)
|
|
{
|
|
if (TryGetBuffer(handle, out var holder))
|
|
{
|
|
return holder.GetBuffer(commandBuffer, offset, size, isWrite);
|
|
}
|
|
|
|
return null;
|
|
}
|
|
|
|
public Auto<DisposableBuffer> GetBufferI8ToI16(CommandBufferScoped cbs, BufferHandle handle, int offset, int size)
|
|
{
|
|
if (TryGetBuffer(handle, out var holder))
|
|
{
|
|
return holder.GetBufferI8ToI16(cbs, offset, size);
|
|
}
|
|
|
|
return null;
|
|
}
|
|
|
|
public Auto<DisposableBuffer> GetAlignedVertexBuffer(CommandBufferScoped cbs, BufferHandle handle, int offset, int size, int stride, int alignment)
|
|
{
|
|
if (TryGetBuffer(handle, out var holder))
|
|
{
|
|
return holder.GetAlignedVertexBuffer(cbs, offset, size, stride, alignment);
|
|
}
|
|
|
|
return null;
|
|
}
|
|
|
|
public Auto<DisposableBuffer> GetBufferTopologyConversion(CommandBufferScoped cbs, BufferHandle handle, int offset, int size, IndexBufferPattern pattern, int indexSize)
|
|
{
|
|
if (TryGetBuffer(handle, out var holder))
|
|
{
|
|
return holder.GetBufferTopologyConversion(cbs, offset, size, pattern, indexSize);
|
|
}
|
|
|
|
return null;
|
|
}
|
|
|
|
public (Auto<DisposableBuffer>, Auto<DisposableBuffer>) GetBufferTopologyConversionIndirect(
|
|
VulkanRenderer gd,
|
|
CommandBufferScoped cbs,
|
|
BufferRange indexBuffer,
|
|
BufferRange indirectBuffer,
|
|
BufferRange drawCountBuffer,
|
|
IndexBufferPattern pattern,
|
|
int indexSize,
|
|
bool hasDrawCount,
|
|
int maxDrawCount,
|
|
int indirectDataStride)
|
|
{
|
|
BufferHolder drawCountBufferHolder = null;
|
|
|
|
if (!TryGetBuffer(indexBuffer.Handle, out var indexBufferHolder) ||
|
|
!TryGetBuffer(indirectBuffer.Handle, out var indirectBufferHolder) ||
|
|
(hasDrawCount && !TryGetBuffer(drawCountBuffer.Handle, out drawCountBufferHolder)))
|
|
{
|
|
return (null, null);
|
|
}
|
|
|
|
var indexBufferKey = new TopologyConversionIndirectCacheKey(
|
|
gd,
|
|
pattern,
|
|
indexSize,
|
|
indirectBufferHolder,
|
|
indirectBuffer.Offset,
|
|
indirectBuffer.Size);
|
|
|
|
bool hasConvertedIndexBuffer = indexBufferHolder.TryGetCachedConvertedBuffer(
|
|
indexBuffer.Offset,
|
|
indexBuffer.Size,
|
|
indexBufferKey,
|
|
out var convertedIndexBuffer);
|
|
|
|
var indirectBufferKey = new IndirectDataCacheKey(pattern);
|
|
bool hasConvertedIndirectBuffer = indirectBufferHolder.TryGetCachedConvertedBuffer(
|
|
indirectBuffer.Offset,
|
|
indirectBuffer.Size,
|
|
indirectBufferKey,
|
|
out var convertedIndirectBuffer);
|
|
|
|
var drawCountBufferKey = new DrawCountCacheKey();
|
|
bool hasCachedDrawCount = true;
|
|
|
|
if (hasDrawCount)
|
|
{
|
|
hasCachedDrawCount = drawCountBufferHolder.TryGetCachedConvertedBuffer(
|
|
drawCountBuffer.Offset,
|
|
drawCountBuffer.Size,
|
|
drawCountBufferKey,
|
|
out _);
|
|
}
|
|
|
|
if (!hasConvertedIndexBuffer || !hasConvertedIndirectBuffer || !hasCachedDrawCount)
|
|
{
|
|
// The destination index size is always I32.
|
|
|
|
int indexCount = indexBuffer.Size / indexSize;
|
|
|
|
int convertedCount = pattern.GetConvertedCount(indexCount);
|
|
|
|
if (!hasConvertedIndexBuffer)
|
|
{
|
|
convertedIndexBuffer = Create(gd, convertedCount * 4);
|
|
indexBufferKey.SetBuffer(convertedIndexBuffer.GetBuffer());
|
|
indexBufferHolder.AddCachedConvertedBuffer(indexBuffer.Offset, indexBuffer.Size, indexBufferKey, convertedIndexBuffer);
|
|
}
|
|
|
|
if (!hasConvertedIndirectBuffer)
|
|
{
|
|
convertedIndirectBuffer = Create(gd, indirectBuffer.Size);
|
|
indirectBufferHolder.AddCachedConvertedBuffer(indirectBuffer.Offset, indirectBuffer.Size, indirectBufferKey, convertedIndirectBuffer);
|
|
}
|
|
|
|
gd.PipelineInternal.EndRenderPass();
|
|
gd.HelperShader.ConvertIndexBufferIndirect(
|
|
gd,
|
|
cbs,
|
|
indirectBufferHolder,
|
|
convertedIndirectBuffer,
|
|
drawCountBuffer,
|
|
indexBufferHolder,
|
|
convertedIndexBuffer,
|
|
pattern,
|
|
indexSize,
|
|
indexBuffer.Offset,
|
|
indexBuffer.Size,
|
|
indirectBuffer.Offset,
|
|
hasDrawCount,
|
|
maxDrawCount,
|
|
indirectDataStride);
|
|
|
|
// Any modification of the indirect buffer should invalidate the index buffers that are associated with it,
|
|
// since we used the indirect data to find the range of the index buffer that is used.
|
|
|
|
var indexBufferDependency = new Dependency(
|
|
indexBufferHolder,
|
|
indexBuffer.Offset,
|
|
indexBuffer.Size,
|
|
indexBufferKey);
|
|
|
|
indirectBufferHolder.AddCachedConvertedBufferDependency(
|
|
indirectBuffer.Offset,
|
|
indirectBuffer.Size,
|
|
indirectBufferKey,
|
|
indexBufferDependency);
|
|
|
|
if (hasDrawCount)
|
|
{
|
|
if (!hasCachedDrawCount)
|
|
{
|
|
drawCountBufferHolder.AddCachedConvertedBuffer(drawCountBuffer.Offset, drawCountBuffer.Size, drawCountBufferKey, null);
|
|
}
|
|
|
|
// If we have a draw count, any modification of the draw count should invalidate all indirect buffers
|
|
// where we used it to find the range of indirect data that is actually used.
|
|
|
|
var indirectBufferDependency = new Dependency(
|
|
indirectBufferHolder,
|
|
indirectBuffer.Offset,
|
|
indirectBuffer.Size,
|
|
indirectBufferKey);
|
|
|
|
drawCountBufferHolder.AddCachedConvertedBufferDependency(
|
|
drawCountBuffer.Offset,
|
|
drawCountBuffer.Size,
|
|
drawCountBufferKey,
|
|
indirectBufferDependency);
|
|
}
|
|
}
|
|
|
|
return (convertedIndexBuffer.GetBuffer(), convertedIndirectBuffer.GetBuffer());
|
|
}
|
|
|
|
public Auto<DisposableBuffer> GetBuffer(CommandBuffer commandBuffer, BufferHandle handle, bool isWrite, out int size)
|
|
{
|
|
if (TryGetBuffer(handle, out var holder))
|
|
{
|
|
size = holder.Size;
|
|
return holder.GetBuffer(commandBuffer, isWrite);
|
|
}
|
|
|
|
size = 0;
|
|
return null;
|
|
}
|
|
|
|
public ReadOnlySpan<byte> GetData(BufferHandle handle, int offset, int size)
|
|
{
|
|
if (TryGetBuffer(handle, out var holder))
|
|
{
|
|
return holder.GetData(offset, size);
|
|
}
|
|
|
|
return ReadOnlySpan<byte>.Empty;
|
|
}
|
|
|
|
public void SetData<T>(BufferHandle handle, int offset, ReadOnlySpan<T> data) where T : unmanaged
|
|
{
|
|
SetData(handle, offset, MemoryMarshal.Cast<T, byte>(data), null, null);
|
|
}
|
|
|
|
public void SetData(BufferHandle handle, int offset, ReadOnlySpan<byte> data, CommandBufferScoped? cbs, Action endRenderPass)
|
|
{
|
|
if (TryGetBuffer(handle, out var holder))
|
|
{
|
|
holder.SetData(offset, data, cbs, endRenderPass);
|
|
}
|
|
}
|
|
|
|
public void Delete(BufferHandle handle)
|
|
{
|
|
if (TryGetBuffer(handle, out var holder))
|
|
{
|
|
holder.Dispose();
|
|
_buffers.Remove((int)Unsafe.As<BufferHandle, ulong>(ref handle));
|
|
}
|
|
}
|
|
|
|
private bool TryGetBuffer(BufferHandle handle, out BufferHolder holder)
|
|
{
|
|
return _buffers.TryGetValue((int)Unsafe.As<BufferHandle, ulong>(ref handle), out holder);
|
|
}
|
|
|
|
protected virtual void Dispose(bool disposing)
|
|
{
|
|
if (disposing)
|
|
{
|
|
foreach (BufferHolder buffer in _buffers)
|
|
{
|
|
buffer.Dispose();
|
|
}
|
|
|
|
_buffers.Clear();
|
|
StagingBuffer.Dispose();
|
|
}
|
|
}
|
|
|
|
public void Dispose()
|
|
{
|
|
Dispose(true);
|
|
}
|
|
}
|
|
}
|