diff --git a/Ryujinx.Graphics.Gpu/Image/Texture.cs b/Ryujinx.Graphics.Gpu/Image/Texture.cs
index 0f952ffd4f..b484a266b9 100644
--- a/Ryujinx.Graphics.Gpu/Image/Texture.cs
+++ b/Ryujinx.Graphics.Gpu/Image/Texture.cs
@@ -84,6 +84,8 @@ namespace Ryujinx.Graphics.Gpu.Image
private int _sequenceNumber;
+ private bool _noSync;
+
/// <summary>
/// Constructs a new instance of the cached GPU texture.
/// </summary>
@@ -301,7 +303,7 @@ namespace Ryujinx.Graphics.Gpu.Image
{
// Texture buffers are not handled here, instead they are invalidated (if modified)
// when the texture is bound. This is handled by the buffer manager.
- if ((_sequenceNumber == _context.SequenceNumber && _hasData) || Info.Target == Target.TextureBuffer)
+ if ((_sequenceNumber == _context.SequenceNumber && _hasData) || _noSync)
{
return;
}
@@ -999,6 +1001,7 @@ namespace Ryujinx.Graphics.Gpu.Image
_depth = info.GetDepth();
_layers = info.GetLayers();
+ _noSync = Info.Target == Target.TextureBuffer;
}
/// <summary>
diff --git a/Ryujinx.Graphics.Texture/BlockLinearLayout.cs b/Ryujinx.Graphics.Texture/BlockLinearLayout.cs
index b95db70290..7a5ac75f39 100644
--- a/Ryujinx.Graphics.Texture/BlockLinearLayout.cs
+++ b/Ryujinx.Graphics.Texture/BlockLinearLayout.cs
@@ -33,6 +33,10 @@ namespace Ryujinx.Graphics.Texture
private int _robSize;
private int _sliceSize;
+ // Variables for built in iteration.
+ private int _yPart;
+ private int _zPart;
+
public BlockLinearLayout(
int width,
int height,
@@ -97,5 +101,50 @@ namespace Ryujinx.Graphics.Texture
return offset;
}
+
+ // Functions for built in iteration.
+ // Components of the offset can be updated separately, and combined to save some time.
+
+ [MethodImpl(MethodImplOptions.AggressiveInlining)]
+ public void SetY(int y)
+ {
+ int yh = y / GobHeight;
+ int offset = (yh >> _bhShift) * _robSize;
+
+ offset += (yh & _bhMask) * GobSize;
+
+ offset += ((y & 0x07) >> 1) << 6;
+ offset += ((y & 0x01) >> 0) << 4;
+
+ _yPart = offset;
+ }
+
+ [MethodImpl(MethodImplOptions.AggressiveInlining)]
+ public void SetZ(int z)
+ {
+ int offset = (z >> _bdShift) * _sliceSize;
+
+ offset += ((z & _bdMask) * GobSize) << _bhShift;
+
+ _zPart = offset;
+ }
+
+ [MethodImpl(MethodImplOptions.AggressiveInlining)]
+ public int GetOffsetWithLineOffset(int x)
+ {
+ int offset = (x / GobStride) << _xShift;
+
+ offset += ((x & 0x3f) >> 5) << 8;
+ offset += ((x & 0x1f) >> 4) << 5;
+ offset += (x & 0x0f);
+
+ return offset + _yPart + _zPart;
+ }
+
+ [MethodImpl(MethodImplOptions.AggressiveInlining)]
+ public int GetOffset(int x)
+ {
+ return GetOffsetWithLineOffset(x << _bppShift);
+ }
}
}
\ No newline at end of file
diff --git a/Ryujinx.Graphics.Texture/LayoutConverter.cs b/Ryujinx.Graphics.Texture/LayoutConverter.cs
index ce2b37b54c..f4c5cd4417 100644
--- a/Ryujinx.Graphics.Texture/LayoutConverter.cs
+++ b/Ryujinx.Graphics.Texture/LayoutConverter.cs
@@ -1,12 +1,20 @@
using Ryujinx.Common;
using System;
-
+using System.Runtime.InteropServices;
+using System.Runtime.Intrinsics;
using static Ryujinx.Graphics.Texture.BlockLinearConstants;
namespace Ryujinx.Graphics.Texture
{
public static class LayoutConverter
{
+ [StructLayout(LayoutKind.Sequential, Pack = 1, Size = 12)]
+ private struct Bpp12Pixel
+ {
+ private ulong _elem1;
+ private uint _elem2;
+ }
+
private const int HostStrideAlignment = 4;
public static Span<byte> ConvertBlockLinearToLinear(
@@ -41,14 +49,14 @@ namespace Ryujinx.Graphics.Texture
int mipGobBlocksInY = gobBlocksInY;
int mipGobBlocksInZ = gobBlocksInZ;
- int gobWidth = (GobStride / bytesPerPixel) * gobBlocksInTileX;
+ int gobWidth = (GobStride / bytesPerPixel) * gobBlocksInTileX;
int gobHeight = gobBlocksInY * GobHeight;
for (int level = 0; level < levels; level++)
{
- int w = Math.Max(1, width >> level);
+ int w = Math.Max(1, width >> level);
int h = Math.Max(1, height >> level);
- int d = Math.Max(1, depth >> level);
+ int d = Math.Max(1, depth >> level);
w = BitUtils.DivRoundUp(w, blockWidth);
h = BitUtils.DivRoundUp(h, blockHeight);
@@ -86,36 +94,66 @@ namespace Ryujinx.Graphics.Texture
mipGobBlocksInZ,
bytesPerPixel);
- for (int layer = 0; layer < layers; layer++)
+ unsafe void Convert<T>(Span<byte> output, ReadOnlySpan<byte> data) where T : unmanaged
{
- int inBaseOffset = layer * sizeInfo.LayerSize + sizeInfo.GetMipOffset(level);
-
- for (int z = 0; z < d; z++)
- for (int y = 0; y < h; y++)
+ fixed (byte* outputBPtr = output, dataBPtr = data)
{
- for (int x = 0; x < strideTrunc; x += 16)
+ for (int layer = 0; layer < layers; layer++)
{
- int offset = inBaseOffset + layoutConverter.GetOffsetWithLineOffset(x, y, z);
+ int inBaseOffset = layer * sizeInfo.LayerSize + sizeInfo.GetMipOffset(level);
- Span<byte> dest = output.Slice(outOffs + x, 16);
+ for (int z = 0; z < d; z++)
+ {
+ layoutConverter.SetZ(z);
+ for (int y = 0; y < h; y++)
+ {
+ layoutConverter.SetY(y);
+ for (int x = 0; x < strideTrunc; x += 16)
+ {
+ int offset = inBaseOffset + layoutConverter.GetOffsetWithLineOffset(x);
- data.Slice(offset, 16).CopyTo(dest);
+ *(Vector128<byte>*)(outputBPtr + outOffs + x) = *(Vector128<byte>*)(dataBPtr + offset);
+ }
+
+ for (int x = xStart; x < w; x++)
+ {
+ int offset = inBaseOffset + layoutConverter.GetOffset(x);
+
+ ((T*)(outputBPtr + outOffs))[x] = *(T*)(dataBPtr + offset);
+ }
+
+ outOffs += stride;
+ }
+ }
}
-
- for (int x = xStart; x < w; x++)
- {
- int offset = inBaseOffset + layoutConverter.GetOffset(x, y, z);
-
- Span<byte> dest = output.Slice(outOffs + x * bytesPerPixel, bytesPerPixel);
-
- data.Slice(offset, bytesPerPixel).CopyTo(dest);
- }
-
- outOffs += stride;
}
}
- }
+ switch (bytesPerPixel)
+ {
+ case 1:
+ Convert<byte>(output, data);
+ break;
+ case 2:
+ Convert<ushort>(output, data);
+ break;
+ case 4:
+ Convert<uint>(output, data);
+ break;
+ case 8:
+ Convert<ulong>(output, data);
+ break;
+ case 12:
+ Convert<Bpp12Pixel>(output, data);
+ break;
+ case 16:
+ Convert<Vector128<byte>>(output, data);
+ break;
+
+ default:
+ throw new NotSupportedException($"Unable to convert ${bytesPerPixel} bpp pixel format.");
+ }
+ }
return output;
}
@@ -137,18 +175,47 @@ namespace Ryujinx.Graphics.Texture
int outOffs = 0;
- for (int y = 0; y < h; y++)
+ unsafe void Convert<T>(Span<byte> output, ReadOnlySpan<byte> data) where T : unmanaged
{
- for (int x = 0; x < w; x++)
+ fixed (byte* outputBPtr = output, dataBPtr = data)
{
- int offset = y * stride + x * bytesPerPixel;
+ for (int y = 0; y < h; y++)
+ {
+ for (int x = 0; x < w; x++)
+ {
+ int offset = y * stride + x * bytesPerPixel;
- Span<byte> dest = output.Slice(outOffs + x * bytesPerPixel, bytesPerPixel);
+ ((T*)(outputBPtr + outOffs))[x] = *(T*)(dataBPtr + offset);
+ }
- data.Slice(offset, bytesPerPixel).CopyTo(dest);
+ outOffs += outStride;
+ }
}
+ }
- outOffs += outStride;
+ switch (bytesPerPixel)
+ {
+ case 1:
+ Convert<byte>(output, data);
+ break;
+ case 2:
+ Convert<ushort>(output, data);
+ break;
+ case 4:
+ Convert<uint>(output, data);
+ break;
+ case 8:
+ Convert<ulong>(output, data);
+ break;
+ case 12:
+ Convert<Bpp12Pixel>(output, data);
+ break;
+ case 16:
+ Convert<Vector128<byte>>(output, data);
+ break;
+
+ default:
+ throw new NotSupportedException($"Unable to convert ${bytesPerPixel} bpp pixel format.");
}
return output;
@@ -217,25 +284,59 @@ namespace Ryujinx.Graphics.Texture
mipGobBlocksInZ,
bytesPerPixel);
- for (int layer = 0; layer < layers; layer++)
+ unsafe void Convert<T>(Span<byte> output, ReadOnlySpan<byte> data) where T : unmanaged
{
- int outBaseOffset = layer * sizeInfo.LayerSize + sizeInfo.GetMipOffset(level);
-
- for (int z = 0; z < d; z++)
- for (int y = 0; y < h; y++)
+ fixed (byte* outputBPtr = output, dataBPtr = data)
{
- for (int x = 0; x < w; x++)
+ T* outputPtr = (T*)outputBPtr, dataPtr = (T*)dataBPtr;
+ for (int layer = 0; layer < layers; layer++)
{
- int offset = outBaseOffset + layoutConverter.GetOffset(x, y, z);
+ int outBaseOffset = layer * sizeInfo.LayerSize + sizeInfo.GetMipOffset(level);
- Span<byte> dest = output.Slice(offset, bytesPerPixel);
+ for (int z = 0; z < d; z++)
+ {
+ layoutConverter.SetZ(z);
+ for (int y = 0; y < h; y++)
+ {
+ layoutConverter.SetY(y);
+ for (int x = 0; x < w; x++)
+ {
+ int offset = outBaseOffset + layoutConverter.GetOffset(x);
- data.Slice(inOffs + x * bytesPerPixel, bytesPerPixel).CopyTo(dest);
+ *(T*)(outputBPtr + offset) = ((T*)(dataBPtr + inOffs))[x];
+ }
+
+ inOffs += stride;
+ }
+ }
}
-
- inOffs += stride;
}
}
+
+ switch (bytesPerPixel)
+ {
+ case 1:
+ Convert<byte>(output, data);
+ break;
+ case 2:
+ Convert<ushort>(output, data);
+ break;
+ case 4:
+ Convert<uint>(output, data);
+ break;
+ case 8:
+ Convert<ulong>(output, data);
+ break;
+ case 12:
+ Convert<Bpp12Pixel>(output, data);
+ break;
+ case 16:
+ Convert<Vector128<byte>>(output, data);
+ break;
+
+ default:
+ throw new NotSupportedException($"Unable to convert ${bytesPerPixel} bpp pixel format.");
+ }
}
return output;
@@ -259,18 +360,47 @@ namespace Ryujinx.Graphics.Texture
int inOffs = 0;
- for (int y = 0; y < h; y++)
+ unsafe void Convert<T>(Span<byte> output, ReadOnlySpan<byte> data) where T : unmanaged
{
- for (int x = 0; x < w; x++)
+ fixed (byte* outputBPtr = output, dataBPtr = data)
{
- int offset = y * stride + x * bytesPerPixel;
+ for (int y = 0; y < h; y++)
+ {
+ for (int x = 0; x < w; x++)
+ {
+ int offset = y * stride + x * bytesPerPixel;
- Span<byte> dest = output.Slice(offset, bytesPerPixel);
+ *(T*)(outputBPtr + offset) = ((T*)(dataBPtr + inOffs))[x];
+ }
- data.Slice(inOffs + x * bytesPerPixel, bytesPerPixel).CopyTo(dest);
+ inOffs += inStride;
+ }
}
+ }
- inOffs += inStride;
+ switch (bytesPerPixel)
+ {
+ case 1:
+ Convert<byte>(output, data);
+ break;
+ case 2:
+ Convert<ushort>(output, data);
+ break;
+ case 4:
+ Convert<uint>(output, data);
+ break;
+ case 8:
+ Convert<ulong>(output, data);
+ break;
+ case 12:
+ Convert<Bpp12Pixel>(output, data);
+ break;
+ case 16:
+ Convert<Vector128<byte>>(output, data);
+ break;
+
+ default:
+ throw new NotSupportedException($"Unable to convert ${bytesPerPixel} bpp pixel format.");
}
return output;