1
0
Fork 0
mirror of https://github.com/Ryujinx/Ryujinx.git synced 2024-12-23 21:56:02 +00:00
Ryujinx/Ryujinx.Graphics.OpenGL/VertexArray.cs

281 lines
8.8 KiB
C#
Raw Normal View History

2019-10-13 07:02:07 +01:00
using OpenTK.Graphics.OpenGL;
2019-12-29 17:41:50 +00:00
using Ryujinx.Graphics.GAL;
2019-10-13 07:02:07 +01:00
using System;
using System.Numerics;
2021-01-26 21:44:07 +00:00
using System.Runtime.CompilerServices;
2019-10-13 07:02:07 +01:00
namespace Ryujinx.Graphics.OpenGL
{
class VertexArray : IDisposable
{
2019-12-31 22:09:49 +00:00
public int Handle { get; private set; }
2019-10-13 07:02:07 +01:00
private readonly VertexAttribDescriptor[] _vertexAttribs;
private readonly VertexBufferDescriptor[] _vertexBuffers;
private int _minVertexCount;
2019-10-13 07:02:07 +01:00
2021-01-26 21:44:07 +00:00
private uint _vertexAttribsInUse;
private uint _vertexBuffersInUse;
private uint _vertexBuffersLimited;
2021-01-26 21:44:07 +00:00
private BufferRange _indexBuffer;
private BufferHandle _tempIndexBuffer;
private BufferHandle _tempVertexBuffer;
private int _tempVertexBufferSize;
2019-10-13 07:02:07 +01:00
public VertexArray()
{
Handle = GL.GenVertexArray();
_vertexAttribs = new VertexAttribDescriptor[Constants.MaxVertexAttribs];
_vertexBuffers = new VertexBufferDescriptor[Constants.MaxVertexBuffers];
_tempIndexBuffer = Buffer.Create();
2019-10-13 07:02:07 +01:00
}
public void Bind()
{
GL.BindVertexArray(Handle);
}
public void SetVertexBuffers(ReadOnlySpan<VertexBufferDescriptor> vertexBuffers)
2019-10-13 07:02:07 +01:00
{
int minVertexCount = int.MaxValue;
2021-01-26 21:44:07 +00:00
int bindingIndex;
for (bindingIndex = 0; bindingIndex < vertexBuffers.Length; bindingIndex++)
2019-10-13 07:02:07 +01:00
{
2021-01-26 21:44:07 +00:00
VertexBufferDescriptor vb = vertexBuffers[bindingIndex];
2019-10-13 07:02:07 +01:00
if (vb.Buffer.Handle != BufferHandle.Null)
{
int vertexCount = vb.Stride <= 0 ? 0 : vb.Buffer.Size / vb.Stride;
if (minVertexCount > vertexCount)
{
minVertexCount = vertexCount;
}
GL.BindVertexBuffer(bindingIndex, vb.Buffer.Handle.ToInt32(), (IntPtr)vb.Buffer.Offset, vb.Stride);
2019-10-13 07:02:07 +01:00
GL.VertexBindingDivisor(bindingIndex, vb.Divisor);
2021-01-26 21:44:07 +00:00
_vertexBuffersInUse |= 1u << bindingIndex;
2019-10-13 07:02:07 +01:00
}
else
{
2021-01-26 21:44:07 +00:00
if ((_vertexBuffersInUse & (1u << bindingIndex)) != 0)
{
GL.BindVertexBuffer(bindingIndex, 0, IntPtr.Zero, 0);
_vertexBuffersInUse &= ~(1u << bindingIndex);
}
2019-10-13 07:02:07 +01:00
}
2021-01-26 21:44:07 +00:00
_vertexBuffers[bindingIndex] = vb;
2019-10-13 07:02:07 +01:00
}
_minVertexCount = minVertexCount;
2019-10-13 07:02:07 +01:00
}
public void SetVertexAttributes(ReadOnlySpan<VertexAttribDescriptor> vertexAttribs)
2019-10-13 07:02:07 +01:00
{
int index = 0;
2019-10-13 07:02:07 +01:00
for (; index < vertexAttribs.Length; index++)
2019-10-13 07:02:07 +01:00
{
VertexAttribDescriptor attrib = vertexAttribs[index];
2021-01-26 21:44:07 +00:00
if (attrib.Equals(_vertexAttribs[index]))
{
continue;
}
2019-10-13 07:02:07 +01:00
FormatInfo fmtInfo = FormatTable.GetFormatInfo(attrib.Format);
if (attrib.IsZero)
{
// Disabling the attribute causes the shader to read a constant value.
// We currently set the constant to (0, 0, 0, 0).
2021-01-26 21:44:07 +00:00
DisableVertexAttrib(index);
}
else
{
2021-01-26 21:44:07 +00:00
EnableVertexAttrib(index);
}
2019-10-13 07:02:07 +01:00
int offset = attrib.Offset;
int size = fmtInfo.Components;
bool isFloat = fmtInfo.PixelType == PixelType.Float ||
fmtInfo.PixelType == PixelType.HalfFloat;
if (isFloat || fmtInfo.Normalized || fmtInfo.Scaled)
{
VertexAttribType type = (VertexAttribType)fmtInfo.PixelType;
GL.VertexAttribFormat(index, size, type, fmtInfo.Normalized, offset);
2019-10-13 07:02:07 +01:00
}
else
{
VertexAttribIntegerType type = (VertexAttribIntegerType)fmtInfo.PixelType;
GL.VertexAttribIFormat(index, size, type, offset);
2019-10-13 07:02:07 +01:00
}
GL.VertexAttribBinding(index, attrib.BufferIndex);
2019-10-13 07:02:07 +01:00
_vertexAttribs[index] = attrib;
2019-10-13 07:02:07 +01:00
}
for (; index < Constants.MaxVertexAttribs; index++)
2019-10-13 07:02:07 +01:00
{
2021-01-26 21:44:07 +00:00
DisableVertexAttrib(index);
2019-10-13 07:02:07 +01:00
}
}
public void SetIndexBuffer(BufferRange range)
{
_indexBuffer = range;
GL.BindBuffer(BufferTarget.ElementArrayBuffer, range.Handle.ToInt32());
}
public void SetRangeOfIndexBuffer()
{
Buffer.Resize(_tempIndexBuffer, _indexBuffer.Size);
Buffer.Copy(_indexBuffer.Handle, _tempIndexBuffer, _indexBuffer.Offset, 0, _indexBuffer.Size);
GL.BindBuffer(BufferTarget.ElementArrayBuffer, _tempIndexBuffer.ToInt32());
}
public void RestoreIndexBuffer()
2019-10-13 07:02:07 +01:00
{
GL.BindBuffer(BufferTarget.ElementArrayBuffer, _indexBuffer.Handle.ToInt32());
2019-10-13 07:02:07 +01:00
}
public void PreDraw(int vertexCount)
{
LimitVertexBuffers(vertexCount);
}
public void PreDrawVbUnbounded()
{
UnlimitVertexBuffers();
}
public void LimitVertexBuffers(int vertexCount)
{
// Is it possible for the draw to fetch outside the bounds of any vertex buffer currently bound?
if (vertexCount <= _minVertexCount)
{
return;
}
// If the draw can fetch out of bounds, let's ensure that it will only fetch zeros rather than memory garbage.
int currentTempVbOffset = 0;
uint buffersInUse = _vertexBuffersInUse;
while (buffersInUse != 0)
{
int vbIndex = BitOperations.TrailingZeroCount(buffersInUse);
ref var vb = ref _vertexBuffers[vbIndex];
int requiredSize = vertexCount * vb.Stride;
if (vb.Buffer.Size < requiredSize)
{
BufferHandle tempVertexBuffer = EnsureTempVertexBufferSize(currentTempVbOffset + requiredSize);
Buffer.Copy(vb.Buffer.Handle, tempVertexBuffer, vb.Buffer.Offset, currentTempVbOffset, vb.Buffer.Size);
Buffer.Clear(tempVertexBuffer, currentTempVbOffset + vb.Buffer.Size, requiredSize - vb.Buffer.Size, 0);
GL.BindVertexBuffer(vbIndex, tempVertexBuffer.ToInt32(), (IntPtr)currentTempVbOffset, vb.Stride);
currentTempVbOffset += requiredSize;
_vertexBuffersLimited |= 1u << vbIndex;
}
buffersInUse &= ~(1u << vbIndex);
}
}
private BufferHandle EnsureTempVertexBufferSize(int size)
{
BufferHandle tempVertexBuffer = _tempVertexBuffer;
if (_tempVertexBufferSize < size)
{
_tempVertexBufferSize = size;
if (tempVertexBuffer == BufferHandle.Null)
{
tempVertexBuffer = Buffer.Create(size);
_tempVertexBuffer = tempVertexBuffer;
return tempVertexBuffer;
}
Buffer.Resize(_tempVertexBuffer, size);
}
return tempVertexBuffer;
}
public void UnlimitVertexBuffers()
{
uint buffersLimited = _vertexBuffersLimited;
if (buffersLimited == 0)
{
return;
}
while (buffersLimited != 0)
{
int vbIndex = BitOperations.TrailingZeroCount(buffersLimited);
ref var vb = ref _vertexBuffers[vbIndex];
GL.BindVertexBuffer(vbIndex, vb.Buffer.Handle.ToInt32(), (IntPtr)vb.Buffer.Offset, vb.Stride);
buffersLimited &= ~(1u << vbIndex);
}
_vertexBuffersLimited = 0;
}
2021-01-26 21:44:07 +00:00
[MethodImpl(MethodImplOptions.AggressiveInlining)]
private void EnableVertexAttrib(int index)
{
uint mask = 1u << index;
2019-10-13 07:02:07 +01:00
2021-01-26 21:44:07 +00:00
if ((_vertexAttribsInUse & mask) == 0)
{
_vertexAttribsInUse |= mask;
GL.EnableVertexAttribArray(index);
2019-10-13 07:02:07 +01:00
}
2021-01-26 21:44:07 +00:00
}
2019-10-13 07:02:07 +01:00
2021-01-26 21:44:07 +00:00
[MethodImpl(MethodImplOptions.AggressiveInlining)]
private void DisableVertexAttrib(int index)
{
uint mask = 1u << index;
if ((_vertexAttribsInUse & mask) != 0)
{
_vertexAttribsInUse &= ~mask;
GL.DisableVertexAttribArray(index);
GL.VertexAttrib4(index, 0f, 0f, 0f, 1f);
2021-01-26 21:44:07 +00:00
}
2019-10-13 07:02:07 +01:00
}
public void Dispose()
{
2019-12-31 22:09:49 +00:00
if (Handle != 0)
{
GL.DeleteVertexArray(Handle);
Handle = 0;
}
2019-10-13 07:02:07 +01:00
}
}
}