mirror of
https://github.com/Ryujinx/Ryujinx.git
synced 2024-11-09 08:08:32 +00:00
79adba4402
* Add support for render scale to vertex stage. Occasionally games read off textureSize on the vertex stage to inform the fragment shader what size a texture is without querying in there. Scales were not present in the vertex shader to correct the sizes, so games were providing the raw upscaled texture size to the fragment shader, which was incorrect. One downside is that the fragment and vertex support buffer description must be identical, so the full size scales array must be defined when used. I don't think this will have an impact though. Another is that the fragment texture count must be updated when vertex shader textures are used. I'd like to correct this so that the update is folded into the update for the scales. Also cleans up a bunch of things, like it making no sense to call CommitRenderScale for each stage. Fixes render scale causing a weird offset bloom in Super Mario Party and Clubhouse Games. Clubhouse Games still has a pixelated look in a number of its games due to something else it does in the shader. * Split out support buffer update, lazy updates. * Commit support buffer before compute dispatch * Remove unnecessary qualifier. * Address Feedback
94 lines
2.8 KiB
C#
94 lines
2.8 KiB
C#
using Ryujinx.Graphics.Shader;
|
|
using System;
|
|
using System.Runtime.CompilerServices;
|
|
using System.Runtime.InteropServices;
|
|
|
|
namespace Ryujinx.Graphics.GAL
|
|
{
|
|
public class SupportBufferUpdater : IDisposable
|
|
{
|
|
public SupportBuffer Data;
|
|
public BufferHandle Handle;
|
|
|
|
private IRenderer _renderer;
|
|
private int _startOffset = -1;
|
|
private int _endOffset = -1;
|
|
|
|
public SupportBufferUpdater(IRenderer renderer)
|
|
{
|
|
_renderer = renderer;
|
|
Handle = renderer.CreateBuffer(SupportBuffer.RequiredSize);
|
|
}
|
|
|
|
private void MarkDirty(int startOffset, int byteSize)
|
|
{
|
|
int endOffset = startOffset + byteSize;
|
|
|
|
if (_startOffset == -1)
|
|
{
|
|
_startOffset = startOffset;
|
|
_endOffset = endOffset;
|
|
}
|
|
else
|
|
{
|
|
if (startOffset < _startOffset)
|
|
{
|
|
_startOffset = startOffset;
|
|
}
|
|
|
|
if (endOffset > _endOffset)
|
|
{
|
|
_endOffset = endOffset;
|
|
}
|
|
}
|
|
}
|
|
|
|
public void UpdateFragmentRenderScaleCount(int count)
|
|
{
|
|
if (Data.FragmentRenderScaleCount.X != count)
|
|
{
|
|
Data.FragmentRenderScaleCount.X = count;
|
|
|
|
MarkDirty(SupportBuffer.FragmentRenderScaleCountOffset, sizeof(int));
|
|
}
|
|
}
|
|
|
|
private void UpdateGenericField<T>(int baseOffset, ReadOnlySpan<T> data, Span<T> target, int offset, int count) where T : unmanaged
|
|
{
|
|
data.Slice(0, count).CopyTo(target.Slice(offset));
|
|
|
|
int elemSize = Unsafe.SizeOf<T>();
|
|
|
|
MarkDirty(baseOffset + offset * elemSize, count * elemSize);
|
|
}
|
|
|
|
public void UpdateRenderScale(ReadOnlySpan<Vector4<float>> data, int offset, int count)
|
|
{
|
|
UpdateGenericField(SupportBuffer.GraphicsRenderScaleOffset, data, Data.RenderScale.ToSpan(), offset, count);
|
|
}
|
|
|
|
public void UpdateFragmentIsBgra(ReadOnlySpan<Vector4<int>> data, int offset, int count)
|
|
{
|
|
UpdateGenericField(SupportBuffer.FragmentIsBgraOffset, data, Data.FragmentIsBgra.ToSpan(), offset, count);
|
|
}
|
|
|
|
public void Commit()
|
|
{
|
|
if (_startOffset != -1)
|
|
{
|
|
ReadOnlySpan<byte> data = MemoryMarshal.Cast<SupportBuffer, byte>(MemoryMarshal.CreateSpan(ref Data, 1));
|
|
|
|
_renderer.SetBufferData(Handle, _startOffset, data.Slice(_startOffset, _endOffset - _startOffset));
|
|
|
|
_startOffset = -1;
|
|
_endOffset = -1;
|
|
}
|
|
}
|
|
|
|
public void Dispose()
|
|
{
|
|
_renderer.DeleteBuffer(Handle);
|
|
}
|
|
}
|
|
}
|