mirror of
https://github.com/Ryujinx/Ryujinx.git
synced 2024-09-10 13:43:17 +02:00
Refactor shader GPU state and memory access (#1203)
* Refactor shader GPU state and memory access * Fix NVDEC project build * Address PR feedback and add missing XML comments
This commit is contained in:
parent
7f500e7cae
commit
b8eb6abecc
@ -47,7 +47,7 @@ namespace Ryujinx.Graphics.Gpu
|
||||
{
|
||||
if (Words == null)
|
||||
{
|
||||
Words = MemoryMarshal.Cast<byte, int>(context.MemoryAccessor.GetSpan(EntryAddress, EntryCount * 4)).ToArray();
|
||||
Words = MemoryMarshal.Cast<byte, int>(context.MemoryAccessor.GetSpan(EntryAddress, (int)EntryCount * 4)).ToArray();
|
||||
}
|
||||
}
|
||||
|
||||
|
@ -47,7 +47,7 @@ namespace Ryujinx.Graphics.Gpu.Engine
|
||||
BufferManager.SetComputeUniformBuffer(index, gpuVa, size);
|
||||
}
|
||||
|
||||
ComputeShader cs = ShaderCache.GetComputeShader(
|
||||
ShaderBundle cs = ShaderCache.GetComputeShader(
|
||||
state,
|
||||
shaderGpuVa,
|
||||
qmd.CtaThreadDimension0,
|
||||
@ -68,7 +68,7 @@ namespace Ryujinx.Graphics.Gpu.Engine
|
||||
|
||||
TextureManager.SetComputeTextureBufferIndex(state.Get<int>(MethodOffset.TextureBufferIndex));
|
||||
|
||||
ShaderProgramInfo info = cs.Shader.Program.Info;
|
||||
ShaderProgramInfo info = cs.Shaders[0].Program.Info;
|
||||
|
||||
for (int index = 0; index < info.CBuffers.Count; index++)
|
||||
{
|
||||
|
@ -65,7 +65,7 @@ namespace Ryujinx.Graphics.Gpu.Engine
|
||||
ulong srcAddress = srcBaseAddress + (ulong)srcOffset;
|
||||
ulong dstAddress = dstBaseAddress + (ulong)dstOffset;
|
||||
|
||||
ReadOnlySpan<byte> pixel = _context.PhysicalMemory.GetSpan(srcAddress, (ulong)srcBpp);
|
||||
ReadOnlySpan<byte> pixel = _context.PhysicalMemory.GetSpan(srcAddress, srcBpp);
|
||||
|
||||
_context.PhysicalMemory.Write(dstAddress, pixel);
|
||||
}
|
||||
|
@ -839,7 +839,7 @@ namespace Ryujinx.Graphics.Gpu.Engine
|
||||
addressesArray[index] = baseAddress + shader.Offset;
|
||||
}
|
||||
|
||||
GraphicsShader gs = ShaderCache.GetGraphicsShader(state, addresses);
|
||||
ShaderBundle gs = ShaderCache.GetGraphicsShader(state, addresses);
|
||||
|
||||
_vsUsesInstanceId = gs.Shaders[0]?.Program.Info.UsesInstanceId ?? false;
|
||||
|
||||
|
@ -315,7 +315,7 @@ namespace Ryujinx.Graphics.Gpu.Image
|
||||
return;
|
||||
}
|
||||
|
||||
ReadOnlySpan<byte> data = _context.PhysicalMemory.GetSpan(Address, Size);
|
||||
ReadOnlySpan<byte> data = _context.PhysicalMemory.GetSpan(Address, (int)Size);
|
||||
|
||||
// If the texture was modified by the host GPU, we do partial invalidation
|
||||
// of the texture by getting GPU data and merging in the pages of memory
|
||||
|
@ -125,7 +125,7 @@ namespace Ryujinx.Graphics.Gpu.Memory
|
||||
|
||||
int offset = (int)(mAddress - Address);
|
||||
|
||||
HostBuffer.SetData(offset, _context.PhysicalMemory.GetSpan(mAddress, mSize));
|
||||
HostBuffer.SetData(offset, _context.PhysicalMemory.GetSpan(mAddress, (int)mSize));
|
||||
}
|
||||
}
|
||||
|
||||
|
@ -1,4 +1,5 @@
|
||||
using System;
|
||||
using System.Runtime.CompilerServices;
|
||||
using System.Runtime.InteropServices;
|
||||
|
||||
namespace Ryujinx.Graphics.Gpu.Memory
|
||||
@ -25,7 +26,7 @@ namespace Ryujinx.Graphics.Gpu.Memory
|
||||
/// <param name="gpuVa">GPU virtual address where the data is located</param>
|
||||
/// <param name="size">Size of the data in bytes</param>
|
||||
/// <returns>Byte array with the data</returns>
|
||||
public byte[] ReadBytes(ulong gpuVa, ulong size)
|
||||
public byte[] ReadBytes(ulong gpuVa, int size)
|
||||
{
|
||||
return GetSpan(gpuVa, size).ToArray();
|
||||
}
|
||||
@ -35,14 +36,12 @@ namespace Ryujinx.Graphics.Gpu.Memory
|
||||
/// This reads as much data as possible, up to the specified maximum size.
|
||||
/// </summary>
|
||||
/// <param name="gpuVa">GPU virtual address where the data is located</param>
|
||||
/// <param name="maxSize">Maximum size of the data</param>
|
||||
/// <param name="size">Size of the data</param>
|
||||
/// <returns>The span of the data at the specified memory location</returns>
|
||||
public ReadOnlySpan<byte> GetSpan(ulong gpuVa, ulong maxSize)
|
||||
public ReadOnlySpan<byte> GetSpan(ulong gpuVa, int size)
|
||||
{
|
||||
ulong processVa = _context.MemoryManager.Translate(gpuVa);
|
||||
|
||||
ulong size = _context.MemoryManager.GetSubSize(gpuVa, maxSize);
|
||||
|
||||
return _context.PhysicalMemory.GetSpan(processVa, size);
|
||||
}
|
||||
|
||||
@ -52,13 +51,11 @@ namespace Ryujinx.Graphics.Gpu.Memory
|
||||
/// <typeparam name="T">Type of the structure</typeparam>
|
||||
/// <param name="gpuVa">GPU virtual address where the structure is located</param>
|
||||
/// <returns>The structure at the specified memory location</returns>
|
||||
public T Read<T>(ulong gpuVa) where T : struct
|
||||
public T Read<T>(ulong gpuVa) where T : unmanaged
|
||||
{
|
||||
ulong processVa = _context.MemoryManager.Translate(gpuVa);
|
||||
|
||||
ulong size = (uint)Marshal.SizeOf<T>();
|
||||
|
||||
return MemoryMarshal.Cast<byte, T>(_context.PhysicalMemory.GetSpan(processVa, size))[0];
|
||||
return MemoryMarshal.Cast<byte, T>(_context.PhysicalMemory.GetSpan(processVa, Unsafe.SizeOf<T>()))[0];
|
||||
}
|
||||
|
||||
/// <summary>
|
||||
@ -114,7 +111,7 @@ namespace Ryujinx.Graphics.Gpu.Memory
|
||||
/// </summary>
|
||||
/// <param name="gpuVa">GPU virtual address to write the data into</param>
|
||||
/// <param name="data">The data to be written</param>
|
||||
public void Write(ulong gpuVa, Span<byte> data)
|
||||
public void Write(ulong gpuVa, ReadOnlySpan<byte> data)
|
||||
{
|
||||
ulong processVa = _context.MemoryManager.Translate(gpuVa);
|
||||
|
||||
|
@ -240,28 +240,6 @@ namespace Ryujinx.Graphics.Gpu.Memory
|
||||
return PteUnmapped;
|
||||
}
|
||||
|
||||
/// <summary>
|
||||
/// Gets the number of mapped or reserved pages on a given region.
|
||||
/// </summary>
|
||||
/// <param name="gpuVa">Start GPU virtual address of the region</param>
|
||||
/// <param name="maxSize">Maximum size of the data</param>
|
||||
/// <returns>Mapped size in bytes of the specified region</returns>
|
||||
internal ulong GetSubSize(ulong gpuVa, ulong maxSize)
|
||||
{
|
||||
ulong size = 0;
|
||||
|
||||
while (GetPte(gpuVa + size) != PteUnmapped)
|
||||
{
|
||||
size += PageSize;
|
||||
if (size >= maxSize)
|
||||
{
|
||||
return maxSize;
|
||||
}
|
||||
}
|
||||
|
||||
return size;
|
||||
}
|
||||
|
||||
/// <summary>
|
||||
/// Translates a GPU virtual address to a CPU virtual address.
|
||||
/// </summary>
|
||||
@ -279,25 +257,6 @@ namespace Ryujinx.Graphics.Gpu.Memory
|
||||
return baseAddress + (gpuVa & PageMask);
|
||||
}
|
||||
|
||||
/// <summary>
|
||||
/// Checks if a given memory region is currently unmapped.
|
||||
/// </summary>
|
||||
/// <param name="gpuVa">Start GPU virtual address of the region</param>
|
||||
/// <param name="size">Size in bytes of the region</param>
|
||||
/// <returns>True if the region is unmapped (free), false otherwise</returns>
|
||||
public bool IsRegionFree(ulong gpuVa, ulong size)
|
||||
{
|
||||
for (ulong offset = 0; offset < size; offset += PageSize)
|
||||
{
|
||||
if (IsPageInUse(gpuVa + offset))
|
||||
{
|
||||
return false;
|
||||
}
|
||||
}
|
||||
|
||||
return true;
|
||||
}
|
||||
|
||||
/// <summary>
|
||||
/// Checks if a given memory page is mapped or reserved.
|
||||
/// </summary>
|
||||
|
@ -28,9 +28,9 @@ namespace Ryujinx.Graphics.Gpu.Memory
|
||||
/// <param name="address">Start address of the range</param>
|
||||
/// <param name="size">Size in bytes to be range</param>
|
||||
/// <returns>A read only span of the data at the specified memory location</returns>
|
||||
public ReadOnlySpan<byte> GetSpan(ulong address, ulong size)
|
||||
public ReadOnlySpan<byte> GetSpan(ulong address, int size)
|
||||
{
|
||||
return _cpuMemory.GetSpan(address, (int)size);
|
||||
return _cpuMemory.GetSpan(address, size);
|
||||
}
|
||||
|
||||
/// <summary>
|
||||
|
@ -1,31 +0,0 @@
|
||||
using Ryujinx.Graphics.GAL;
|
||||
|
||||
namespace Ryujinx.Graphics.Gpu.Shader
|
||||
{
|
||||
/// <summary>
|
||||
/// Cached compute shader code.
|
||||
/// </summary>
|
||||
class ComputeShader
|
||||
{
|
||||
/// <summary>
|
||||
/// Host shader program object.
|
||||
/// </summary>
|
||||
public IProgram HostProgram { get; }
|
||||
|
||||
/// <summary>
|
||||
/// Cached shader.
|
||||
/// </summary>
|
||||
public CachedShader Shader { get; }
|
||||
|
||||
/// <summary>
|
||||
/// Creates a new instance of the compute shader.
|
||||
/// </summary>
|
||||
/// <param name="hostProgram">Host shader program</param>
|
||||
/// <param name="shader">Cached shader</param>
|
||||
public ComputeShader(IProgram hostProgram, CachedShader shader)
|
||||
{
|
||||
HostProgram = hostProgram;
|
||||
Shader = shader;
|
||||
}
|
||||
}
|
||||
}
|
264
Ryujinx.Graphics.Gpu/Shader/GpuAccessor.cs
Normal file
264
Ryujinx.Graphics.Gpu/Shader/GpuAccessor.cs
Normal file
@ -0,0 +1,264 @@
|
||||
using Ryujinx.Common.Logging;
|
||||
using Ryujinx.Graphics.GAL;
|
||||
using Ryujinx.Graphics.Gpu.Image;
|
||||
using Ryujinx.Graphics.Gpu.State;
|
||||
using Ryujinx.Graphics.Shader;
|
||||
|
||||
namespace Ryujinx.Graphics.Gpu.Shader
|
||||
{
|
||||
/// <summary>
|
||||
/// Represents a GPU state and memory accessor.
|
||||
/// </summary>
|
||||
class GpuAccessor : IGpuAccessor
|
||||
{
|
||||
private readonly GpuContext _context;
|
||||
private readonly GpuState _state;
|
||||
private readonly int _stageIndex;
|
||||
private readonly bool _compute;
|
||||
private readonly int _localSizeX;
|
||||
private readonly int _localSizeY;
|
||||
private readonly int _localSizeZ;
|
||||
private readonly int _localMemorySize;
|
||||
private readonly int _sharedMemorySize;
|
||||
|
||||
/// <summary>
|
||||
/// Creates a new instance of the GPU state accessor for graphics shader translation.
|
||||
/// </summary>
|
||||
/// <param name="context">GPU context</param>
|
||||
/// <param name="state">Current GPU state</param>
|
||||
/// <param name="stageIndex">Graphics shader stage index (0 = Vertex, 4 = Fragment)</param>
|
||||
public GpuAccessor(GpuContext context, GpuState state, int stageIndex)
|
||||
{
|
||||
_context = context;
|
||||
_state = state;
|
||||
_stageIndex = stageIndex;
|
||||
}
|
||||
|
||||
/// <summary>
|
||||
/// Creates a new instance of the GPU state accessor for compute shader translation.
|
||||
/// </summary>
|
||||
/// <param name="context">GPU context</param>
|
||||
/// <param name="state">Current GPU state</param>
|
||||
/// <param name="localSizeX">Local group size X of the compute shader</param>
|
||||
/// <param name="localSizeY">Local group size Y of the compute shader</param>
|
||||
/// <param name="localSizeZ">Local group size Z of the compute shader</param>
|
||||
/// <param name="localMemorySize">Local memory size of the compute shader</param>
|
||||
/// <param name="sharedMemorySize">Shared memory size of the compute shader</param>
|
||||
public GpuAccessor(
|
||||
GpuContext context,
|
||||
GpuState state,
|
||||
int localSizeX,
|
||||
int localSizeY,
|
||||
int localSizeZ,
|
||||
int localMemorySize,
|
||||
int sharedMemorySize)
|
||||
{
|
||||
_context = context;
|
||||
_state = state;
|
||||
_compute = true;
|
||||
_localSizeX = localSizeX;
|
||||
_localSizeY = localSizeY;
|
||||
_localSizeZ = localSizeZ;
|
||||
_localMemorySize = localMemorySize;
|
||||
_sharedMemorySize = sharedMemorySize;
|
||||
}
|
||||
|
||||
/// <summary>
|
||||
/// Prints a log message.
|
||||
/// </summary>
|
||||
/// <param name="message">Message to print</param>
|
||||
public void Log(string message)
|
||||
{
|
||||
Logger.PrintWarning(LogClass.Gpu, $"Shader translator: {message}");
|
||||
}
|
||||
|
||||
/// <summary>
|
||||
/// Reads data from GPU memory.
|
||||
/// </summary>
|
||||
/// <typeparam name="T">Type of the data to be read</typeparam>
|
||||
/// <param name="address">GPU virtual address of the data</param>
|
||||
/// <returns>Data at the memory location</returns>
|
||||
public T MemoryRead<T>(ulong address) where T : unmanaged
|
||||
{
|
||||
return _context.MemoryAccessor.Read<T>(address);
|
||||
}
|
||||
|
||||
/// <summary>
|
||||
/// Queries Local Size X for compute shaders.
|
||||
/// </summary>
|
||||
/// <returns>Local Size X</returns>
|
||||
public int QueryComputeLocalSizeX() => _localSizeX;
|
||||
|
||||
/// <summary>
|
||||
/// Queries Local Size Y for compute shaders.
|
||||
/// </summary>
|
||||
/// <returns>Local Size Y</returns>
|
||||
public int QueryComputeLocalSizeY() => _localSizeY;
|
||||
|
||||
/// <summary>
|
||||
/// Queries Local Size Z for compute shaders.
|
||||
/// </summary>
|
||||
/// <returns>Local Size Z</returns>
|
||||
public int QueryComputeLocalSizeZ() => _localSizeZ;
|
||||
|
||||
/// <summary>
|
||||
/// Queries Local Memory size in bytes for compute shaders.
|
||||
/// </summary>
|
||||
/// <returns>Local Memory size in bytes</returns>
|
||||
public int QueryComputeLocalMemorySize() => _localMemorySize;
|
||||
|
||||
/// <summary>
|
||||
/// Queries Shared Memory size in bytes for compute shaders.
|
||||
/// </summary>
|
||||
/// <returns>Shared Memory size in bytes</returns>
|
||||
public int QueryComputeSharedMemorySize() => _sharedMemorySize;
|
||||
|
||||
/// <summary>
|
||||
/// Queries texture target information.
|
||||
/// </summary>
|
||||
/// <param name="handle">Texture handle</param>
|
||||
/// <returns>True if the texture is a buffer texture, false otherwise</returns>
|
||||
public bool QueryIsTextureBuffer(int handle)
|
||||
{
|
||||
return GetTextureDescriptor(handle).UnpackTextureTarget() == TextureTarget.TextureBuffer;
|
||||
}
|
||||
|
||||
/// <summary>
|
||||
/// Queries texture target information.
|
||||
/// </summary>
|
||||
/// <param name="handle">Texture handle</param>
|
||||
/// <returns>True if the texture is a rectangle texture, false otherwise</returns>
|
||||
public bool QueryIsTextureRectangle(int handle)
|
||||
{
|
||||
var descriptor = GetTextureDescriptor(handle);
|
||||
|
||||
TextureTarget target = descriptor.UnpackTextureTarget();
|
||||
|
||||
bool is2DTexture = target == TextureTarget.Texture2D ||
|
||||
target == TextureTarget.Texture2DRect;
|
||||
|
||||
return !descriptor.UnpackTextureCoordNormalized() && is2DTexture;
|
||||
}
|
||||
|
||||
/// <summary>
|
||||
/// Queries current primitive topology for geometry shaders.
|
||||
/// </summary>
|
||||
/// <returns>Current primitive topology</returns>
|
||||
public InputTopology QueryPrimitiveTopology()
|
||||
{
|
||||
switch (_context.Methods.PrimitiveType)
|
||||
{
|
||||
case PrimitiveType.Points:
|
||||
return InputTopology.Points;
|
||||
case PrimitiveType.Lines:
|
||||
case PrimitiveType.LineLoop:
|
||||
case PrimitiveType.LineStrip:
|
||||
return InputTopology.Lines;
|
||||
case PrimitiveType.LinesAdjacency:
|
||||
case PrimitiveType.LineStripAdjacency:
|
||||
return InputTopology.LinesAdjacency;
|
||||
case PrimitiveType.Triangles:
|
||||
case PrimitiveType.TriangleStrip:
|
||||
case PrimitiveType.TriangleFan:
|
||||
return InputTopology.Triangles;
|
||||
case PrimitiveType.TrianglesAdjacency:
|
||||
case PrimitiveType.TriangleStripAdjacency:
|
||||
return InputTopology.TrianglesAdjacency;
|
||||
}
|
||||
|
||||
return InputTopology.Points;
|
||||
}
|
||||
|
||||
/// <summary>
|
||||
/// Queries host storage buffer alignment required.
|
||||
/// </summary>
|
||||
/// <returns>Host storage buffer alignment in bytes</returns>
|
||||
public int QueryStorageBufferOffsetAlignment() => _context.Capabilities.StorageBufferOffsetAlignment;
|
||||
|
||||
/// <summary>
|
||||
/// Queries host GPU non-constant texture offset support.
|
||||
/// </summary>
|
||||
/// <returns>True if the GPU and driver supports non-constant texture offsets, false otherwise</returns>
|
||||
public bool QuerySupportsNonConstantTextureOffset() => _context.Capabilities.SupportsNonConstantTextureOffset;
|
||||
|
||||
/// <summary>
|
||||
/// Queries texture format information, for shaders using image load or store.
|
||||
/// </summary>
|
||||
/// <remarks>
|
||||
/// This only returns non-compressed color formats.
|
||||
/// If the format of the texture is a compressed, depth or unsupported format, then a default value is returned.
|
||||
/// </remarks>
|
||||
/// <param name="handle">Texture handle</param>
|
||||
/// <returns>Color format of the non-compressed texture</returns>
|
||||
public TextureFormat QueryTextureFormat(int handle)
|
||||
{
|
||||
var descriptor = GetTextureDescriptor(handle);
|
||||
|
||||
if (!FormatTable.TryGetTextureFormat(descriptor.UnpackFormat(), descriptor.UnpackSrgb(), out FormatInfo formatInfo))
|
||||
{
|
||||
return TextureFormat.Unknown;
|
||||
}
|
||||
|
||||
return formatInfo.Format switch
|
||||
{
|
||||
Format.R8Unorm => TextureFormat.R8Unorm,
|
||||
Format.R8Snorm => TextureFormat.R8Snorm,
|
||||
Format.R8Uint => TextureFormat.R8Uint,
|
||||
Format.R8Sint => TextureFormat.R8Sint,
|
||||
Format.R16Float => TextureFormat.R16Float,
|
||||
Format.R16Unorm => TextureFormat.R16Unorm,
|
||||
Format.R16Snorm => TextureFormat.R16Snorm,
|
||||
Format.R16Uint => TextureFormat.R16Uint,
|
||||
Format.R16Sint => TextureFormat.R16Sint,
|
||||
Format.R32Float => TextureFormat.R32Float,
|
||||
Format.R32Uint => TextureFormat.R32Uint,
|
||||
Format.R32Sint => TextureFormat.R32Sint,
|
||||
Format.R8G8Unorm => TextureFormat.R8G8Unorm,
|
||||
Format.R8G8Snorm => TextureFormat.R8G8Snorm,
|
||||
Format.R8G8Uint => TextureFormat.R8G8Uint,
|
||||
Format.R8G8Sint => TextureFormat.R8G8Sint,
|
||||
Format.R16G16Float => TextureFormat.R16G16Float,
|
||||
Format.R16G16Unorm => TextureFormat.R16G16Unorm,
|
||||
Format.R16G16Snorm => TextureFormat.R16G16Snorm,
|
||||
Format.R16G16Uint => TextureFormat.R16G16Uint,
|
||||
Format.R16G16Sint => TextureFormat.R16G16Sint,
|
||||
Format.R32G32Float => TextureFormat.R32G32Float,
|
||||
Format.R32G32Uint => TextureFormat.R32G32Uint,
|
||||
Format.R32G32Sint => TextureFormat.R32G32Sint,
|
||||
Format.R8G8B8A8Unorm => TextureFormat.R8G8B8A8Unorm,
|
||||
Format.R8G8B8A8Snorm => TextureFormat.R8G8B8A8Snorm,
|
||||
Format.R8G8B8A8Uint => TextureFormat.R8G8B8A8Uint,
|
||||
Format.R8G8B8A8Sint => TextureFormat.R8G8B8A8Sint,
|
||||
Format.R16G16B16A16Float => TextureFormat.R16G16B16A16Float,
|
||||
Format.R16G16B16A16Unorm => TextureFormat.R16G16B16A16Unorm,
|
||||
Format.R16G16B16A16Snorm => TextureFormat.R16G16B16A16Snorm,
|
||||
Format.R16G16B16A16Uint => TextureFormat.R16G16B16A16Uint,
|
||||
Format.R16G16B16A16Sint => TextureFormat.R16G16B16A16Sint,
|
||||
Format.R32G32B32A32Float => TextureFormat.R32G32B32A32Float,
|
||||
Format.R32G32B32A32Uint => TextureFormat.R32G32B32A32Uint,
|
||||
Format.R32G32B32A32Sint => TextureFormat.R32G32B32A32Sint,
|
||||
Format.R10G10B10A2Unorm => TextureFormat.R10G10B10A2Unorm,
|
||||
Format.R10G10B10A2Uint => TextureFormat.R10G10B10A2Uint,
|
||||
Format.R11G11B10Float => TextureFormat.R11G11B10Float,
|
||||
_ => TextureFormat.Unknown
|
||||
};
|
||||
}
|
||||
|
||||
/// <summary>
|
||||
/// Gets the texture descriptor for a given texture on the pool.
|
||||
/// </summary>
|
||||
/// <param name="handle">Index of the texture (this is the shader "fake" handle)</param>
|
||||
/// <returns>Texture descriptor</returns>
|
||||
private Image.TextureDescriptor GetTextureDescriptor(int handle)
|
||||
{
|
||||
if (_compute)
|
||||
{
|
||||
return _context.Methods.TextureManager.GetComputeTextureDescriptor(_state, handle);
|
||||
}
|
||||
else
|
||||
{
|
||||
return _context.Methods.TextureManager.GetGraphicsTextureDescriptor(_state, _stageIndex, handle);
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
@ -1,28 +0,0 @@
|
||||
using Ryujinx.Graphics.GAL;
|
||||
|
||||
namespace Ryujinx.Graphics.Gpu.Shader
|
||||
{
|
||||
/// <summary>
|
||||
/// Cached graphics shader code for all stages.
|
||||
/// </summary>
|
||||
class GraphicsShader
|
||||
{
|
||||
/// <summary>
|
||||
/// Host shader program object.
|
||||
/// </summary>
|
||||
public IProgram HostProgram { get; set; }
|
||||
|
||||
/// <summary>
|
||||
/// Compiled shader for each shader stage.
|
||||
/// </summary>
|
||||
public CachedShader[] Shaders { get; }
|
||||
|
||||
/// <summary>
|
||||
/// Creates a new instance of cached graphics shader.
|
||||
/// </summary>
|
||||
public GraphicsShader()
|
||||
{
|
||||
Shaders = new CachedShader[Constants.ShaderStages];
|
||||
}
|
||||
}
|
||||
}
|
46
Ryujinx.Graphics.Gpu/Shader/ShaderBundle.cs
Normal file
46
Ryujinx.Graphics.Gpu/Shader/ShaderBundle.cs
Normal file
@ -0,0 +1,46 @@
|
||||
using Ryujinx.Graphics.GAL;
|
||||
using System;
|
||||
|
||||
namespace Ryujinx.Graphics.Gpu.Shader
|
||||
{
|
||||
/// <summary>
|
||||
/// Represents a program composed of one or more shader stages (for graphics shaders),
|
||||
/// or a single shader (for compute shaders).
|
||||
/// </summary>
|
||||
class ShaderBundle : IDisposable
|
||||
{
|
||||
/// <summary>
|
||||
/// Host shader program object.
|
||||
/// </summary>
|
||||
public IProgram HostProgram { get; }
|
||||
|
||||
/// <summary>
|
||||
/// Compiled shader for each shader stage.
|
||||
/// </summary>
|
||||
public ShaderCodeHolder[] Shaders { get; }
|
||||
|
||||
/// <summary>
|
||||
/// Creates a new instance of the shader bundle.
|
||||
/// </summary>
|
||||
/// <param name="hostProgram">Host program with all the shader stages</param>
|
||||
/// <param name="shaders">Shaders</param>
|
||||
public ShaderBundle(IProgram hostProgram, params ShaderCodeHolder[] shaders)
|
||||
{
|
||||
HostProgram = hostProgram;
|
||||
Shaders = shaders;
|
||||
}
|
||||
|
||||
/// <summary>
|
||||
/// Dispose of the host shader resources.
|
||||
/// </summary>
|
||||
public void Dispose()
|
||||
{
|
||||
HostProgram.Dispose();
|
||||
|
||||
foreach (ShaderCodeHolder holder in Shaders)
|
||||
{
|
||||
holder?.HostShader.Dispose();
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
@ -1,33 +1,25 @@
|
||||
using Ryujinx.Common.Logging;
|
||||
using Ryujinx.Graphics.GAL;
|
||||
using Ryujinx.Graphics.Gpu.Image;
|
||||
using Ryujinx.Graphics.Gpu.State;
|
||||
using Ryujinx.Graphics.Shader;
|
||||
using Ryujinx.Graphics.Shader.Translation;
|
||||
using System;
|
||||
using System.Collections.Generic;
|
||||
using System.Runtime.InteropServices;
|
||||
|
||||
namespace Ryujinx.Graphics.Gpu.Shader
|
||||
{
|
||||
using TextureDescriptor = Image.TextureDescriptor;
|
||||
|
||||
/// <summary>
|
||||
/// Memory cache of shader code.
|
||||
/// </summary>
|
||||
class ShaderCache : IDisposable
|
||||
{
|
||||
private const int MaxProgramSize = 0x100000;
|
||||
|
||||
private const TranslationFlags DefaultFlags = TranslationFlags.DebugMode;
|
||||
|
||||
private GpuContext _context;
|
||||
private readonly GpuContext _context;
|
||||
|
||||
private ShaderDumper _dumper;
|
||||
private readonly ShaderDumper _dumper;
|
||||
|
||||
private Dictionary<ulong, List<ComputeShader>> _cpPrograms;
|
||||
|
||||
private Dictionary<ShaderAddresses, List<GraphicsShader>> _gpPrograms;
|
||||
private readonly Dictionary<ulong, List<ShaderBundle>> _cpPrograms;
|
||||
private readonly Dictionary<ShaderAddresses, List<ShaderBundle>> _gpPrograms;
|
||||
|
||||
/// <summary>
|
||||
/// Creates a new instance of the shader cache.
|
||||
@ -39,9 +31,8 @@ namespace Ryujinx.Graphics.Gpu.Shader
|
||||
|
||||
_dumper = new ShaderDumper();
|
||||
|
||||
_cpPrograms = new Dictionary<ulong, List<ComputeShader>>();
|
||||
|
||||
_gpPrograms = new Dictionary<ShaderAddresses, List<GraphicsShader>>();
|
||||
_cpPrograms = new Dictionary<ulong, List<ShaderBundle>>();
|
||||
_gpPrograms = new Dictionary<ShaderAddresses, List<ShaderBundle>>();
|
||||
}
|
||||
|
||||
/// <summary>
|
||||
@ -58,7 +49,7 @@ namespace Ryujinx.Graphics.Gpu.Shader
|
||||
/// <param name="localMemorySize">Local memory size of the compute shader</param>
|
||||
/// <param name="sharedMemorySize">Shared memory size of the compute shader</param>
|
||||
/// <returns>Compiled compute shader code</returns>
|
||||
public ComputeShader GetComputeShader(
|
||||
public ShaderBundle GetComputeShader(
|
||||
GpuState state,
|
||||
ulong gpuVa,
|
||||
int localSizeX,
|
||||
@ -67,20 +58,20 @@ namespace Ryujinx.Graphics.Gpu.Shader
|
||||
int localMemorySize,
|
||||
int sharedMemorySize)
|
||||
{
|
||||
bool isCached = _cpPrograms.TryGetValue(gpuVa, out List<ComputeShader> list);
|
||||
bool isCached = _cpPrograms.TryGetValue(gpuVa, out List<ShaderBundle> list);
|
||||
|
||||
if (isCached)
|
||||
{
|
||||
foreach (ComputeShader cachedCpShader in list)
|
||||
foreach (ShaderBundle cachedCpShader in list)
|
||||
{
|
||||
if (!IsShaderDifferent(cachedCpShader, gpuVa))
|
||||
if (IsShaderEqual(cachedCpShader, gpuVa))
|
||||
{
|
||||
return cachedCpShader;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
CachedShader shader = TranslateComputeShader(
|
||||
ShaderCodeHolder shader = TranslateComputeShader(
|
||||
state,
|
||||
gpuVa,
|
||||
localSizeX,
|
||||
@ -93,11 +84,11 @@ namespace Ryujinx.Graphics.Gpu.Shader
|
||||
|
||||
IProgram hostProgram = _context.Renderer.CreateProgram(new IShader[] { shader.HostShader });
|
||||
|
||||
ComputeShader cpShader = new ComputeShader(hostProgram, shader);
|
||||
ShaderBundle cpShader = new ShaderBundle(hostProgram, shader);
|
||||
|
||||
if (!isCached)
|
||||
{
|
||||
list = new List<ComputeShader>();
|
||||
list = new List<ShaderBundle>();
|
||||
|
||||
_cpPrograms.Add(gpuVa, list);
|
||||
}
|
||||
@ -117,42 +108,42 @@ namespace Ryujinx.Graphics.Gpu.Shader
|
||||
/// <param name="state">Current GPU state</param>
|
||||
/// <param name="addresses">Addresses of the shaders for each stage</param>
|
||||
/// <returns>Compiled graphics shader code</returns>
|
||||
public GraphicsShader GetGraphicsShader(GpuState state, ShaderAddresses addresses)
|
||||
public ShaderBundle GetGraphicsShader(GpuState state, ShaderAddresses addresses)
|
||||
{
|
||||
bool isCached = _gpPrograms.TryGetValue(addresses, out List<GraphicsShader> list);
|
||||
bool isCached = _gpPrograms.TryGetValue(addresses, out List<ShaderBundle> list);
|
||||
|
||||
if (isCached)
|
||||
{
|
||||
foreach (GraphicsShader cachedGpShaders in list)
|
||||
foreach (ShaderBundle cachedGpShaders in list)
|
||||
{
|
||||
if (!IsShaderDifferent(cachedGpShaders, addresses))
|
||||
if (IsShaderEqual(cachedGpShaders, addresses))
|
||||
{
|
||||
return cachedGpShaders;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
GraphicsShader gpShaders = new GraphicsShader();
|
||||
ShaderCodeHolder[] shaders = new ShaderCodeHolder[Constants.ShaderStages];
|
||||
|
||||
if (addresses.VertexA != 0)
|
||||
{
|
||||
gpShaders.Shaders[0] = TranslateGraphicsShader(state, ShaderStage.Vertex, addresses.Vertex, addresses.VertexA);
|
||||
shaders[0] = TranslateGraphicsShader(state, ShaderStage.Vertex, addresses.Vertex, addresses.VertexA);
|
||||
}
|
||||
else
|
||||
{
|
||||
gpShaders.Shaders[0] = TranslateGraphicsShader(state, ShaderStage.Vertex, addresses.Vertex);
|
||||
shaders[0] = TranslateGraphicsShader(state, ShaderStage.Vertex, addresses.Vertex);
|
||||
}
|
||||
|
||||
gpShaders.Shaders[1] = TranslateGraphicsShader(state, ShaderStage.TessellationControl, addresses.TessControl);
|
||||
gpShaders.Shaders[2] = TranslateGraphicsShader(state, ShaderStage.TessellationEvaluation, addresses.TessEvaluation);
|
||||
gpShaders.Shaders[3] = TranslateGraphicsShader(state, ShaderStage.Geometry, addresses.Geometry);
|
||||
gpShaders.Shaders[4] = TranslateGraphicsShader(state, ShaderStage.Fragment, addresses.Fragment);
|
||||
shaders[1] = TranslateGraphicsShader(state, ShaderStage.TessellationControl, addresses.TessControl);
|
||||
shaders[2] = TranslateGraphicsShader(state, ShaderStage.TessellationEvaluation, addresses.TessEvaluation);
|
||||
shaders[3] = TranslateGraphicsShader(state, ShaderStage.Geometry, addresses.Geometry);
|
||||
shaders[4] = TranslateGraphicsShader(state, ShaderStage.Fragment, addresses.Fragment);
|
||||
|
||||
List<IShader> hostShaders = new List<IShader>();
|
||||
|
||||
for (int stage = 0; stage < gpShaders.Shaders.Length; stage++)
|
||||
for (int stage = 0; stage < Constants.ShaderStages; stage++)
|
||||
{
|
||||
ShaderProgram program = gpShaders.Shaders[stage]?.Program;
|
||||
ShaderProgram program = shaders[stage]?.Program;
|
||||
|
||||
if (program == null)
|
||||
{
|
||||
@ -161,16 +152,18 @@ namespace Ryujinx.Graphics.Gpu.Shader
|
||||
|
||||
IShader hostShader = _context.Renderer.CompileShader(program);
|
||||
|
||||
gpShaders.Shaders[stage].HostShader = hostShader;
|
||||
shaders[stage].HostShader = hostShader;
|
||||
|
||||
hostShaders.Add(hostShader);
|
||||
}
|
||||
|
||||
gpShaders.HostProgram = _context.Renderer.CreateProgram(hostShaders.ToArray());
|
||||
IProgram hostProgram = _context.Renderer.CreateProgram(hostShaders.ToArray());
|
||||
|
||||
ShaderBundle gpShaders = new ShaderBundle(hostProgram, shaders);
|
||||
|
||||
if (!isCached)
|
||||
{
|
||||
list = new List<GraphicsShader>();
|
||||
list = new List<ShaderBundle>();
|
||||
|
||||
_gpPrograms.Add(addresses, list);
|
||||
}
|
||||
@ -181,27 +174,27 @@ namespace Ryujinx.Graphics.Gpu.Shader
|
||||
}
|
||||
|
||||
/// <summary>
|
||||
/// Checks if compute shader code in memory is different from the cached shader.
|
||||
/// Checks if compute shader code in memory is equal to the cached shader.
|
||||
/// </summary>
|
||||
/// <param name="cpShader">Cached compute shader</param>
|
||||
/// <param name="gpuVa">GPU virtual address of the shader code in memory</param>
|
||||
/// <returns>True if the code is different, false otherwise</returns>
|
||||
private bool IsShaderDifferent(ComputeShader cpShader, ulong gpuVa)
|
||||
private bool IsShaderEqual(ShaderBundle cpShader, ulong gpuVa)
|
||||
{
|
||||
return IsShaderDifferent(cpShader.Shader, gpuVa);
|
||||
return IsShaderEqual(cpShader.Shaders[0], gpuVa);
|
||||
}
|
||||
|
||||
/// <summary>
|
||||
/// Checks if graphics shader code from all stages in memory is different from the cached shaders.
|
||||
/// Checks if graphics shader code from all stages in memory are equal to the cached shaders.
|
||||
/// </summary>
|
||||
/// <param name="gpShaders">Cached graphics shaders</param>
|
||||
/// <param name="addresses">GPU virtual addresses of all enabled shader stages</param>
|
||||
/// <returns>True if the code is different, false otherwise</returns>
|
||||
private bool IsShaderDifferent(GraphicsShader gpShaders, ShaderAddresses addresses)
|
||||
private bool IsShaderEqual(ShaderBundle gpShaders, ShaderAddresses addresses)
|
||||
{
|
||||
for (int stage = 0; stage < gpShaders.Shaders.Length; stage++)
|
||||
{
|
||||
CachedShader shader = gpShaders.Shaders[stage];
|
||||
ShaderCodeHolder shader = gpShaders.Shaders[stage];
|
||||
|
||||
ulong gpuVa = 0;
|
||||
|
||||
@ -214,13 +207,13 @@ namespace Ryujinx.Graphics.Gpu.Shader
|
||||
case 4: gpuVa = addresses.Fragment; break;
|
||||
}
|
||||
|
||||
if (IsShaderDifferent(shader, gpuVa))
|
||||
if (!IsShaderEqual(shader, gpuVa, addresses.VertexA))
|
||||
{
|
||||
return true;
|
||||
return false;
|
||||
}
|
||||
}
|
||||
|
||||
return false;
|
||||
return true;
|
||||
}
|
||||
|
||||
/// <summary>
|
||||
@ -228,17 +221,27 @@ namespace Ryujinx.Graphics.Gpu.Shader
|
||||
/// </summary>
|
||||
/// <param name="shader">Cached shader to compare with</param>
|
||||
/// <param name="gpuVa">GPU virtual address of the binary shader code</param>
|
||||
/// <param name="gpuVaA">Optional GPU virtual address of the "Vertex A" binary shader code</param>
|
||||
/// <returns>True if the code is different, false otherwise</returns>
|
||||
private bool IsShaderDifferent(CachedShader shader, ulong gpuVa)
|
||||
private bool IsShaderEqual(ShaderCodeHolder shader, ulong gpuVa, ulong gpuVaA = 0)
|
||||
{
|
||||
if (shader == null)
|
||||
{
|
||||
return false;
|
||||
return true;
|
||||
}
|
||||
|
||||
ReadOnlySpan<byte> memoryCode = _context.MemoryAccessor.GetSpan(gpuVa, (ulong)shader.Code.Length * 4);
|
||||
ReadOnlySpan<byte> memoryCode = _context.MemoryAccessor.GetSpan(gpuVa, shader.Code.Length);
|
||||
|
||||
return !MemoryMarshal.Cast<byte, int>(memoryCode).SequenceEqual(shader.Code);
|
||||
bool equals = memoryCode.SequenceEqual(shader.Code);
|
||||
|
||||
if (equals && shader.Code2 != null)
|
||||
{
|
||||
memoryCode = _context.MemoryAccessor.GetSpan(gpuVaA, shader.Code2.Length);
|
||||
|
||||
equals = memoryCode.SequenceEqual(shader.Code2);
|
||||
}
|
||||
|
||||
return equals;
|
||||
}
|
||||
|
||||
/// <summary>
|
||||
@ -252,7 +255,7 @@ namespace Ryujinx.Graphics.Gpu.Shader
|
||||
/// <param name="localMemorySize">Local memory size of the compute shader</param>
|
||||
/// <param name="sharedMemorySize">Shared memory size of the compute shader</param>
|
||||
/// <returns>Compiled compute shader code</returns>
|
||||
private CachedShader TranslateComputeShader(
|
||||
private ShaderCodeHolder TranslateComputeShader(
|
||||
GpuState state,
|
||||
ulong gpuVa,
|
||||
int localSizeX,
|
||||
@ -266,40 +269,13 @@ namespace Ryujinx.Graphics.Gpu.Shader
|
||||
return null;
|
||||
}
|
||||
|
||||
int QueryInfo(QueryInfoName info, int index)
|
||||
{
|
||||
return info switch
|
||||
{
|
||||
QueryInfoName.ComputeLocalSizeX
|
||||
=> localSizeX,
|
||||
QueryInfoName.ComputeLocalSizeY
|
||||
=> localSizeY,
|
||||
QueryInfoName.ComputeLocalSizeZ
|
||||
=> localSizeZ,
|
||||
QueryInfoName.ComputeLocalMemorySize
|
||||
=> localMemorySize,
|
||||
QueryInfoName.ComputeSharedMemorySize
|
||||
=> sharedMemorySize,
|
||||
QueryInfoName.IsTextureBuffer
|
||||
=> Convert.ToInt32(QueryIsTextureBuffer(state, 0, index, compute: true)),
|
||||
QueryInfoName.IsTextureRectangle
|
||||
=> Convert.ToInt32(QueryIsTextureRectangle(state, 0, index, compute: true)),
|
||||
QueryInfoName.TextureFormat
|
||||
=> (int)QueryTextureFormat(state, 0, index, compute: true),
|
||||
_
|
||||
=> QueryInfoCommon(info)
|
||||
};
|
||||
}
|
||||
|
||||
TranslatorCallbacks callbacks = new TranslatorCallbacks(QueryInfo, PrintLog);
|
||||
GpuAccessor gpuAccessor = new GpuAccessor(_context, state, localSizeX, localSizeY, localSizeZ, localMemorySize, sharedMemorySize);
|
||||
|
||||
ShaderProgram program;
|
||||
|
||||
ReadOnlySpan<byte> code = _context.MemoryAccessor.GetSpan(gpuVa, MaxProgramSize);
|
||||
program = Translator.Translate(gpuVa, gpuAccessor, DefaultFlags | TranslationFlags.Compute);
|
||||
|
||||
program = Translator.Translate(code, callbacks, DefaultFlags | TranslationFlags.Compute);
|
||||
|
||||
int[] codeCached = MemoryMarshal.Cast<byte, int>(code.Slice(0, program.Size)).ToArray();
|
||||
byte[] code = _context.MemoryAccessor.ReadBytes(gpuVa, program.Size);
|
||||
|
||||
_dumper.Dump(code, compute: true, out string fullPath, out string codePath);
|
||||
|
||||
@ -309,7 +285,7 @@ namespace Ryujinx.Graphics.Gpu.Shader
|
||||
program.Prepend("// " + fullPath);
|
||||
}
|
||||
|
||||
return new CachedShader(program, codeCached);
|
||||
return new ShaderCodeHolder(program, code);
|
||||
}
|
||||
|
||||
/// <summary>
|
||||
@ -323,45 +299,21 @@ namespace Ryujinx.Graphics.Gpu.Shader
|
||||
/// <param name="gpuVa">GPU virtual address of the shader code</param>
|
||||
/// <param name="gpuVaA">Optional GPU virtual address of the "Vertex A" shader code</param>
|
||||
/// <returns>Compiled graphics shader code</returns>
|
||||
private CachedShader TranslateGraphicsShader(GpuState state, ShaderStage stage, ulong gpuVa, ulong gpuVaA = 0)
|
||||
private ShaderCodeHolder TranslateGraphicsShader(GpuState state, ShaderStage stage, ulong gpuVa, ulong gpuVaA = 0)
|
||||
{
|
||||
if (gpuVa == 0)
|
||||
{
|
||||
return null;
|
||||
}
|
||||
|
||||
int QueryInfo(QueryInfoName info, int index)
|
||||
{
|
||||
return info switch
|
||||
{
|
||||
QueryInfoName.IsTextureBuffer
|
||||
=> Convert.ToInt32(QueryIsTextureBuffer(state, (int)stage - 1, index, compute: false)),
|
||||
QueryInfoName.IsTextureRectangle
|
||||
=> Convert.ToInt32(QueryIsTextureRectangle(state, (int)stage - 1, index, compute: false)),
|
||||
QueryInfoName.PrimitiveTopology
|
||||
=> (int)QueryPrimitiveTopology(),
|
||||
QueryInfoName.TextureFormat
|
||||
=> (int)QueryTextureFormat(state, (int)stage - 1, index, compute: false),
|
||||
_
|
||||
=> QueryInfoCommon(info)
|
||||
};
|
||||
}
|
||||
|
||||
TranslatorCallbacks callbacks = new TranslatorCallbacks(QueryInfo, PrintLog);
|
||||
|
||||
ShaderProgram program;
|
||||
|
||||
int[] codeCached = null;
|
||||
GpuAccessor gpuAccessor = new GpuAccessor(_context, state, (int)stage - 1);
|
||||
|
||||
if (gpuVaA != 0)
|
||||
{
|
||||
ReadOnlySpan<byte> codeA = _context.MemoryAccessor.GetSpan(gpuVaA, MaxProgramSize);
|
||||
ReadOnlySpan<byte> codeB = _context.MemoryAccessor.GetSpan(gpuVa, MaxProgramSize);
|
||||
ShaderProgram program = Translator.Translate(gpuVaA, gpuVa, gpuAccessor, DefaultFlags);
|
||||
|
||||
program = Translator.Translate(codeA, codeB, callbacks, DefaultFlags);
|
||||
|
||||
// TODO: We should also take "codeA" into account.
|
||||
codeCached = MemoryMarshal.Cast<byte, int>(codeB.Slice(0, program.Size)).ToArray();
|
||||
byte[] codeA = _context.MemoryAccessor.ReadBytes(gpuVaA, program.SizeA);
|
||||
byte[] codeB = _context.MemoryAccessor.ReadBytes(gpuVa, program.Size);
|
||||
|
||||
_dumper.Dump(codeA, compute: false, out string fullPathA, out string codePathA);
|
||||
_dumper.Dump(codeB, compute: false, out string fullPathB, out string codePathB);
|
||||
@ -373,14 +325,14 @@ namespace Ryujinx.Graphics.Gpu.Shader
|
||||
program.Prepend("// " + codePathA);
|
||||
program.Prepend("// " + fullPathA);
|
||||
}
|
||||
|
||||
return new ShaderCodeHolder(program, codeB, codeA);
|
||||
}
|
||||
else
|
||||
{
|
||||
ReadOnlySpan<byte> code = _context.MemoryAccessor.GetSpan(gpuVa, MaxProgramSize);
|
||||
ShaderProgram program = Translator.Translate(gpuVa, gpuAccessor, DefaultFlags);
|
||||
|
||||
program = Translator.Translate(code, callbacks, DefaultFlags);
|
||||
|
||||
codeCached = MemoryMarshal.Cast<byte, int>(code.Slice(0, program.Size)).ToArray();
|
||||
byte[] code = _context.MemoryAccessor.ReadBytes(gpuVa, program.Size);
|
||||
|
||||
_dumper.Dump(code, compute: false, out string fullPath, out string codePath);
|
||||
|
||||
@ -389,195 +341,9 @@ namespace Ryujinx.Graphics.Gpu.Shader
|
||||
program.Prepend("// " + codePath);
|
||||
program.Prepend("// " + fullPath);
|
||||
}
|
||||
|
||||
return new ShaderCodeHolder(program, code);
|
||||
}
|
||||
|
||||
ulong address = _context.MemoryManager.Translate(gpuVa);
|
||||
|
||||
return new CachedShader(program, codeCached);
|
||||
}
|
||||
|
||||
/// <summary>
|
||||
/// Gets the primitive topology for the current draw.
|
||||
/// This is required by geometry shaders.
|
||||
/// </summary>
|
||||
/// <returns>Primitive topology</returns>
|
||||
private InputTopology QueryPrimitiveTopology()
|
||||
{
|
||||
switch (_context.Methods.PrimitiveType)
|
||||
{
|
||||
case PrimitiveType.Points:
|
||||
return InputTopology.Points;
|
||||
case PrimitiveType.Lines:
|
||||
case PrimitiveType.LineLoop:
|
||||
case PrimitiveType.LineStrip:
|
||||
return InputTopology.Lines;
|
||||
case PrimitiveType.LinesAdjacency:
|
||||
case PrimitiveType.LineStripAdjacency:
|
||||
return InputTopology.LinesAdjacency;
|
||||
case PrimitiveType.Triangles:
|
||||
case PrimitiveType.TriangleStrip:
|
||||
case PrimitiveType.TriangleFan:
|
||||
return InputTopology.Triangles;
|
||||
case PrimitiveType.TrianglesAdjacency:
|
||||
case PrimitiveType.TriangleStripAdjacency:
|
||||
return InputTopology.TrianglesAdjacency;
|
||||
}
|
||||
|
||||
return InputTopology.Points;
|
||||
}
|
||||
|
||||
/// <summary>
|
||||
/// Check if the target of a given texture is texture buffer.
|
||||
/// This is required as 1D textures and buffer textures shares the same sampler type on binary shader code,
|
||||
/// but not on GLSL.
|
||||
/// </summary>
|
||||
/// <param name="state">Current GPU state</param>
|
||||
/// <param name="stageIndex">Index of the shader stage</param>
|
||||
/// <param name="handle">Index of the texture (this is the shader "fake" handle)</param>
|
||||
/// <param name="compute">Indicates whenever the texture descriptor is for the compute or graphics engine</param>
|
||||
/// <returns>True if the texture is a buffer texture, false otherwise</returns>
|
||||
private bool QueryIsTextureBuffer(GpuState state, int stageIndex, int handle, bool compute)
|
||||
{
|
||||
return GetTextureDescriptor(state, stageIndex, handle, compute).UnpackTextureTarget() == TextureTarget.TextureBuffer;
|
||||
}
|
||||
|
||||
/// <summary>
|
||||
/// Check if the target of a given texture is texture rectangle.
|
||||
/// This is required as 2D textures and rectangle textures shares the same sampler type on binary shader code,
|
||||
/// but not on GLSL.
|
||||
/// </summary>
|
||||
/// <param name="state">Current GPU state</param>
|
||||
/// <param name="stageIndex">Index of the shader stage</param>
|
||||
/// <param name="handle">Index of the texture (this is the shader "fake" handle)</param>
|
||||
/// <param name="compute">Indicates whenever the texture descriptor is for the compute or graphics engine</param>
|
||||
/// <returns>True if the texture is a rectangle texture, false otherwise</returns>
|
||||
private bool QueryIsTextureRectangle(GpuState state, int stageIndex, int handle, bool compute)
|
||||
{
|
||||
var descriptor = GetTextureDescriptor(state, stageIndex, handle, compute);
|
||||
|
||||
TextureTarget target = descriptor.UnpackTextureTarget();
|
||||
|
||||
bool is2DTexture = target == TextureTarget.Texture2D ||
|
||||
target == TextureTarget.Texture2DRect;
|
||||
|
||||
return !descriptor.UnpackTextureCoordNormalized() && is2DTexture;
|
||||
}
|
||||
|
||||
/// <summary>
|
||||
/// Queries the format of a given texture.
|
||||
/// </summary>
|
||||
/// <param name="state">Current GPU state</param>
|
||||
/// <param name="stageIndex">Index of the shader stage. This is ignored if <paramref name="compute"/> is true</param>
|
||||
/// <param name="handle">Index of the texture (this is the shader "fake" handle)</param>
|
||||
/// <param name="compute">Indicates whenever the texture descriptor is for the compute or graphics engine</param>
|
||||
/// <returns>The texture format</returns>
|
||||
private TextureFormat QueryTextureFormat(GpuState state, int stageIndex, int handle, bool compute)
|
||||
{
|
||||
return QueryTextureFormat(GetTextureDescriptor(state, stageIndex, handle, compute));
|
||||
}
|
||||
|
||||
/// <summary>
|
||||
/// Queries the format of a given texture.
|
||||
/// </summary>
|
||||
/// <param name="descriptor">Descriptor of the texture from the texture pool</param>
|
||||
/// <returns>The texture format</returns>
|
||||
private static TextureFormat QueryTextureFormat(TextureDescriptor descriptor)
|
||||
{
|
||||
if (!FormatTable.TryGetTextureFormat(descriptor.UnpackFormat(), descriptor.UnpackSrgb(), out FormatInfo formatInfo))
|
||||
{
|
||||
return TextureFormat.Unknown;
|
||||
}
|
||||
|
||||
return formatInfo.Format switch
|
||||
{
|
||||
Format.R8Unorm => TextureFormat.R8Unorm,
|
||||
Format.R8Snorm => TextureFormat.R8Snorm,
|
||||
Format.R8Uint => TextureFormat.R8Uint,
|
||||
Format.R8Sint => TextureFormat.R8Sint,
|
||||
Format.R16Float => TextureFormat.R16Float,
|
||||
Format.R16Unorm => TextureFormat.R16Unorm,
|
||||
Format.R16Snorm => TextureFormat.R16Snorm,
|
||||
Format.R16Uint => TextureFormat.R16Uint,
|
||||
Format.R16Sint => TextureFormat.R16Sint,
|
||||
Format.R32Float => TextureFormat.R32Float,
|
||||
Format.R32Uint => TextureFormat.R32Uint,
|
||||
Format.R32Sint => TextureFormat.R32Sint,
|
||||
Format.R8G8Unorm => TextureFormat.R8G8Unorm,
|
||||
Format.R8G8Snorm => TextureFormat.R8G8Snorm,
|
||||
Format.R8G8Uint => TextureFormat.R8G8Uint,
|
||||
Format.R8G8Sint => TextureFormat.R8G8Sint,
|
||||
Format.R16G16Float => TextureFormat.R16G16Float,
|
||||
Format.R16G16Unorm => TextureFormat.R16G16Unorm,
|
||||
Format.R16G16Snorm => TextureFormat.R16G16Snorm,
|
||||
Format.R16G16Uint => TextureFormat.R16G16Uint,
|
||||
Format.R16G16Sint => TextureFormat.R16G16Sint,
|
||||
Format.R32G32Float => TextureFormat.R32G32Float,
|
||||
Format.R32G32Uint => TextureFormat.R32G32Uint,
|
||||
Format.R32G32Sint => TextureFormat.R32G32Sint,
|
||||
Format.R8G8B8A8Unorm => TextureFormat.R8G8B8A8Unorm,
|
||||
Format.R8G8B8A8Snorm => TextureFormat.R8G8B8A8Snorm,
|
||||
Format.R8G8B8A8Uint => TextureFormat.R8G8B8A8Uint,
|
||||
Format.R8G8B8A8Sint => TextureFormat.R8G8B8A8Sint,
|
||||
Format.R16G16B16A16Float => TextureFormat.R16G16B16A16Float,
|
||||
Format.R16G16B16A16Unorm => TextureFormat.R16G16B16A16Unorm,
|
||||
Format.R16G16B16A16Snorm => TextureFormat.R16G16B16A16Snorm,
|
||||
Format.R16G16B16A16Uint => TextureFormat.R16G16B16A16Uint,
|
||||
Format.R16G16B16A16Sint => TextureFormat.R16G16B16A16Sint,
|
||||
Format.R32G32B32A32Float => TextureFormat.R32G32B32A32Float,
|
||||
Format.R32G32B32A32Uint => TextureFormat.R32G32B32A32Uint,
|
||||
Format.R32G32B32A32Sint => TextureFormat.R32G32B32A32Sint,
|
||||
Format.R10G10B10A2Unorm => TextureFormat.R10G10B10A2Unorm,
|
||||
Format.R10G10B10A2Uint => TextureFormat.R10G10B10A2Uint,
|
||||
Format.R11G11B10Float => TextureFormat.R11G11B10Float,
|
||||
_ => TextureFormat.Unknown
|
||||
};
|
||||
}
|
||||
|
||||
/// <summary>
|
||||
/// Gets the texture descriptor for a given texture on the pool.
|
||||
/// </summary>
|
||||
/// <param name="state">Current GPU state</param>
|
||||
/// <param name="stageIndex">Index of the shader stage. This is ignored if <paramref name="compute"/> is true</param>
|
||||
/// <param name="handle">Index of the texture (this is the shader "fake" handle)</param>
|
||||
/// <param name="compute">Indicates whenever the texture descriptor is for the compute or graphics engine</param>
|
||||
/// <returns>Texture descriptor</returns>
|
||||
private TextureDescriptor GetTextureDescriptor(GpuState state, int stageIndex, int handle, bool compute)
|
||||
{
|
||||
if (compute)
|
||||
{
|
||||
return _context.Methods.TextureManager.GetComputeTextureDescriptor(state, handle);
|
||||
}
|
||||
else
|
||||
{
|
||||
return _context.Methods.TextureManager.GetGraphicsTextureDescriptor(state, stageIndex, handle);
|
||||
}
|
||||
}
|
||||
|
||||
/// <summary>
|
||||
/// Returns information required by both compute and graphics shader compilation.
|
||||
/// </summary>
|
||||
/// <param name="info">Information queried</param>
|
||||
/// <returns>Requested information</returns>
|
||||
private int QueryInfoCommon(QueryInfoName info)
|
||||
{
|
||||
return info switch
|
||||
{
|
||||
QueryInfoName.StorageBufferOffsetAlignment
|
||||
=> _context.Capabilities.StorageBufferOffsetAlignment,
|
||||
QueryInfoName.SupportsNonConstantTextureOffset
|
||||
=> Convert.ToInt32(_context.Capabilities.SupportsNonConstantTextureOffset),
|
||||
_
|
||||
=> 0
|
||||
};
|
||||
}
|
||||
|
||||
/// <summary>
|
||||
/// Prints a warning from the shader code translator.
|
||||
/// </summary>
|
||||
/// <param name="message">Warning message</param>
|
||||
private static void PrintLog(string message)
|
||||
{
|
||||
Logger.PrintWarning(LogClass.Gpu, $"Shader translator: {message}");
|
||||
}
|
||||
|
||||
/// <summary>
|
||||
@ -586,25 +352,19 @@ namespace Ryujinx.Graphics.Gpu.Shader
|
||||
/// </summary>
|
||||
public void Dispose()
|
||||
{
|
||||
foreach (List<ComputeShader> list in _cpPrograms.Values)
|
||||
foreach (List<ShaderBundle> list in _cpPrograms.Values)
|
||||
{
|
||||
foreach (ComputeShader shader in list)
|
||||
foreach (ShaderBundle bundle in list)
|
||||
{
|
||||
shader.HostProgram.Dispose();
|
||||
shader.Shader?.HostShader.Dispose();
|
||||
bundle.Dispose();
|
||||
}
|
||||
}
|
||||
|
||||
foreach (List<GraphicsShader> list in _gpPrograms.Values)
|
||||
foreach (List<ShaderBundle> list in _gpPrograms.Values)
|
||||
{
|
||||
foreach (GraphicsShader shader in list)
|
||||
foreach (ShaderBundle bundle in list)
|
||||
{
|
||||
shader.HostProgram.Dispose();
|
||||
|
||||
foreach (CachedShader cachedShader in shader.Shaders)
|
||||
{
|
||||
cachedShader?.HostShader.Dispose();
|
||||
}
|
||||
bundle.Dispose();
|
||||
}
|
||||
}
|
||||
}
|
||||
|
@ -6,7 +6,7 @@ namespace Ryujinx.Graphics.Gpu.Shader
|
||||
/// <summary>
|
||||
/// Cached shader code for a single shader stage.
|
||||
/// </summary>
|
||||
class CachedShader
|
||||
class ShaderCodeHolder
|
||||
{
|
||||
/// <summary>
|
||||
/// Shader program containing translated code.
|
||||
@ -21,17 +21,24 @@ namespace Ryujinx.Graphics.Gpu.Shader
|
||||
/// <summary>
|
||||
/// Maxwell binary shader code.
|
||||
/// </summary>
|
||||
public int[] Code { get; }
|
||||
public byte[] Code { get; }
|
||||
|
||||
/// <summary>
|
||||
/// Creates a new instace of the cached shader.
|
||||
/// Optional maxwell binary shader code for "Vertex A" shader.
|
||||
/// </summary>
|
||||
public byte[] Code2 { get; }
|
||||
|
||||
/// <summary>
|
||||
/// Creates a new instace of the shader code holder.
|
||||
/// </summary>
|
||||
/// <param name="program">Shader program</param>
|
||||
/// <param name="code">Maxwell binary shader code</param>
|
||||
public CachedShader(ShaderProgram program, int[] code)
|
||||
/// <param name="code2">Optional binary shader code of the "Vertex A" shader, when combined with "Vertex B"</param>
|
||||
public ShaderCodeHolder(ShaderProgram program, byte[] code, byte[] code2 = null)
|
||||
{
|
||||
Program = program;
|
||||
Code = code;
|
||||
Code2 = code2;
|
||||
}
|
||||
}
|
||||
}
|
@ -1,4 +1,3 @@
|
||||
using Ryujinx.Graphics.Shader.Translation;
|
||||
using System;
|
||||
using System.IO;
|
||||
|
||||
@ -11,13 +10,19 @@ namespace Ryujinx.Graphics.Gpu.Shader
|
||||
{
|
||||
private string _runtimeDir;
|
||||
private string _dumpPath;
|
||||
private int _dumpIndex;
|
||||
|
||||
public int CurrentDumpIndex => _dumpIndex;
|
||||
/// <summary>
|
||||
/// Current index of the shader dump binary file.
|
||||
/// This is incremented after each save, in order to give unique names to the files.
|
||||
/// </summary>
|
||||
public int CurrentDumpIndex { get; private set; }
|
||||
|
||||
/// <summary>
|
||||
/// Creates a new instance of the shader dumper.
|
||||
/// </summary>
|
||||
public ShaderDumper()
|
||||
{
|
||||
_dumpIndex = 1;
|
||||
CurrentDumpIndex = 1;
|
||||
}
|
||||
|
||||
/// <summary>
|
||||
@ -27,7 +32,7 @@ namespace Ryujinx.Graphics.Gpu.Shader
|
||||
/// <param name="compute">True for compute shader code, false for graphics shader code</param>
|
||||
/// <param name="fullPath">Output path for the shader code with header included</param>
|
||||
/// <param name="codePath">Output path for the shader code without header</param>
|
||||
public void Dump(ReadOnlySpan<byte> code, bool compute, out string fullPath, out string codePath)
|
||||
public void Dump(byte[] code, bool compute, out string fullPath, out string codePath)
|
||||
{
|
||||
_dumpPath = GraphicsConfig.ShadersDumpPath;
|
||||
|
||||
@ -39,38 +44,34 @@ namespace Ryujinx.Graphics.Gpu.Shader
|
||||
return;
|
||||
}
|
||||
|
||||
string fileName = "Shader" + _dumpIndex.ToString("d4") + ".bin";
|
||||
string fileName = "Shader" + CurrentDumpIndex.ToString("d4") + ".bin";
|
||||
|
||||
fullPath = Path.Combine(FullDir(), fileName);
|
||||
codePath = Path.Combine(CodeDir(), fileName);
|
||||
|
||||
_dumpIndex++;
|
||||
CurrentDumpIndex++;
|
||||
|
||||
code = Translator.ExtractCode(code, compute, out int headerSize);
|
||||
using MemoryStream stream = new MemoryStream(code);
|
||||
BinaryReader codeReader = new BinaryReader(stream);
|
||||
|
||||
using (MemoryStream stream = new MemoryStream(code.ToArray()))
|
||||
using FileStream fullFile = File.Create(fullPath);
|
||||
using FileStream codeFile = File.Create(codePath);
|
||||
BinaryWriter fullWriter = new BinaryWriter(fullFile);
|
||||
BinaryWriter codeWriter = new BinaryWriter(codeFile);
|
||||
|
||||
int headerSize = compute ? 0 : 0x50;
|
||||
|
||||
fullWriter.Write(codeReader.ReadBytes(headerSize));
|
||||
|
||||
byte[] temp = codeReader.ReadBytes(code.Length - headerSize);
|
||||
|
||||
fullWriter.Write(temp);
|
||||
codeWriter.Write(temp);
|
||||
|
||||
// Align to meet nvdisasm requirements.
|
||||
while (codeFile.Length % 0x20 != 0)
|
||||
{
|
||||
BinaryReader codeReader = new BinaryReader(stream);
|
||||
|
||||
using (FileStream fullFile = File.Create(fullPath))
|
||||
using (FileStream codeFile = File.Create(codePath))
|
||||
{
|
||||
BinaryWriter fullWriter = new BinaryWriter(fullFile);
|
||||
BinaryWriter codeWriter = new BinaryWriter(codeFile);
|
||||
|
||||
fullWriter.Write(codeReader.ReadBytes(headerSize));
|
||||
|
||||
byte[] temp = codeReader.ReadBytes(code.Length - headerSize);
|
||||
|
||||
fullWriter.Write(temp);
|
||||
codeWriter.Write(temp);
|
||||
|
||||
// Align to meet nvdisasm requirements.
|
||||
while (codeFile.Length % 0x20 != 0)
|
||||
{
|
||||
codeWriter.Write(0);
|
||||
}
|
||||
}
|
||||
codeWriter.Write(0);
|
||||
}
|
||||
}
|
||||
|
||||
|
@ -1,6 +1,8 @@
|
||||
using Ryujinx.Graphics.Gpu;
|
||||
using Ryujinx.Graphics.Gpu.Memory;
|
||||
using Ryujinx.Graphics.Vic;
|
||||
using System;
|
||||
using System.Runtime.InteropServices;
|
||||
|
||||
namespace Ryujinx.Graphics.VDec
|
||||
{
|
||||
@ -70,7 +72,7 @@ namespace Ryujinx.Graphics.VDec
|
||||
ScalingMatrix8 = gpu.MemoryAccessor.ReadBytes(_decoderContextAddress + 0x220, 2 * 64)
|
||||
};
|
||||
|
||||
byte[] frameData = gpu.MemoryAccessor.ReadBytes(_frameDataAddress, (ulong)frameDataSize);
|
||||
byte[] frameData = gpu.MemoryAccessor.ReadBytes(_frameDataAddress, frameDataSize);
|
||||
|
||||
_h264Decoder.Decode(Params, matrices, frameData);
|
||||
}
|
||||
@ -86,7 +88,7 @@ namespace Ryujinx.Graphics.VDec
|
||||
Ref2Key = (long)gpu.MemoryManager.Translate(_vpxRef2LumaAddress)
|
||||
};
|
||||
|
||||
Vp9FrameHeader header = gpu.MemoryAccessor.Read<Vp9FrameHeader>(_decoderContextAddress + 0x48);
|
||||
Vp9FrameHeader header = ReadStruct<Vp9FrameHeader>(gpu.MemoryAccessor, _decoderContextAddress + 0x48);
|
||||
|
||||
Vp9ProbabilityTables probs = new Vp9ProbabilityTables()
|
||||
{
|
||||
@ -117,7 +119,7 @@ namespace Ryujinx.Graphics.VDec
|
||||
MvHpProbs = gpu.MemoryAccessor.ReadBytes(_vpxProbTablesAddress + 0x54a, 0x2)
|
||||
};
|
||||
|
||||
byte[] frameData = gpu.MemoryAccessor.ReadBytes(_frameDataAddress, (ulong)frameDataSize);
|
||||
byte[] frameData = gpu.MemoryAccessor.ReadBytes(_frameDataAddress, frameDataSize);
|
||||
|
||||
_vp9Decoder.Decode(keys, header, probs, frameData);
|
||||
}
|
||||
@ -127,6 +129,19 @@ namespace Ryujinx.Graphics.VDec
|
||||
}
|
||||
}
|
||||
|
||||
private T ReadStruct<T>(MemoryAccessor accessor, ulong address) where T : struct
|
||||
{
|
||||
byte[] data = accessor.ReadBytes(address, Marshal.SizeOf<T>());
|
||||
|
||||
unsafe
|
||||
{
|
||||
fixed (byte* ptr = data)
|
||||
{
|
||||
return Marshal.PtrToStructure<T>((IntPtr)ptr);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
private void SetDecoderCtxAddr(int[] arguments)
|
||||
{
|
||||
_decoderContextAddress = GetAddress(arguments);
|
||||
|
@ -34,7 +34,7 @@ namespace Ryujinx.Graphics.Shader.CodeGen.Glsl
|
||||
|
||||
if (context.Config.Stage == ShaderStage.Geometry)
|
||||
{
|
||||
string inPrimitive = ((InputTopology)context.Config.QueryInfo(QueryInfoName.PrimitiveTopology)).ToGlslString();
|
||||
string inPrimitive = context.Config.GpuAccessor.QueryPrimitiveTopology().ToGlslString();
|
||||
|
||||
context.AppendLine($"layout ({inPrimitive}) in;");
|
||||
|
||||
@ -48,7 +48,7 @@ namespace Ryujinx.Graphics.Shader.CodeGen.Glsl
|
||||
|
||||
if (context.Config.Stage == ShaderStage.Compute)
|
||||
{
|
||||
int localMemorySize = BitUtils.DivRoundUp(context.Config.QueryInfo(QueryInfoName.ComputeLocalMemorySize), 4);
|
||||
int localMemorySize = BitUtils.DivRoundUp(context.Config.GpuAccessor.QueryComputeLocalMemorySize(), 4);
|
||||
|
||||
if (localMemorySize != 0)
|
||||
{
|
||||
@ -58,7 +58,7 @@ namespace Ryujinx.Graphics.Shader.CodeGen.Glsl
|
||||
context.AppendLine();
|
||||
}
|
||||
|
||||
int sharedMemorySize = BitUtils.DivRoundUp(context.Config.QueryInfo(QueryInfoName.ComputeSharedMemorySize), 4);
|
||||
int sharedMemorySize = BitUtils.DivRoundUp(context.Config.GpuAccessor.QueryComputeSharedMemorySize(), 4);
|
||||
|
||||
if (sharedMemorySize != 0)
|
||||
{
|
||||
@ -124,9 +124,9 @@ namespace Ryujinx.Graphics.Shader.CodeGen.Glsl
|
||||
}
|
||||
else
|
||||
{
|
||||
string localSizeX = NumberFormatter.FormatInt(context.Config.QueryInfo(QueryInfoName.ComputeLocalSizeX));
|
||||
string localSizeY = NumberFormatter.FormatInt(context.Config.QueryInfo(QueryInfoName.ComputeLocalSizeY));
|
||||
string localSizeZ = NumberFormatter.FormatInt(context.Config.QueryInfo(QueryInfoName.ComputeLocalSizeZ));
|
||||
string localSizeX = NumberFormatter.FormatInt(context.Config.GpuAccessor.QueryComputeLocalSizeX());
|
||||
string localSizeY = NumberFormatter.FormatInt(context.Config.GpuAccessor.QueryComputeLocalSizeY());
|
||||
string localSizeZ = NumberFormatter.FormatInt(context.Config.GpuAccessor.QueryComputeLocalSizeZ());
|
||||
|
||||
context.AppendLine(
|
||||
"layout (" +
|
||||
|
@ -1,6 +1,5 @@
|
||||
using Ryujinx.Graphics.Shader.Instructions;
|
||||
using System;
|
||||
using System.Buffers.Binary;
|
||||
using System.Collections.Generic;
|
||||
using System.Linq;
|
||||
|
||||
@ -10,7 +9,7 @@ namespace Ryujinx.Graphics.Shader.Decoders
|
||||
{
|
||||
static class Decoder
|
||||
{
|
||||
public static Block[] Decode(ReadOnlySpan<byte> code, ulong headerSize)
|
||||
public static Block[] Decode(IGpuAccessor gpuAccessor, ulong startAddress)
|
||||
{
|
||||
List<Block> blocks = new List<Block>();
|
||||
|
||||
@ -18,8 +17,6 @@ namespace Ryujinx.Graphics.Shader.Decoders
|
||||
|
||||
Dictionary<ulong, Block> visited = new Dictionary<ulong, Block>();
|
||||
|
||||
ulong maxAddress = (ulong)code.Length - headerSize;
|
||||
|
||||
Block GetBlock(ulong blkAddress)
|
||||
{
|
||||
if (!visited.TryGetValue(blkAddress, out Block block))
|
||||
@ -56,7 +53,7 @@ namespace Ryujinx.Graphics.Shader.Decoders
|
||||
}
|
||||
|
||||
// If we have a block after the current one, set the limit address.
|
||||
ulong limitAddress = maxAddress;
|
||||
ulong limitAddress = ulong.MaxValue;
|
||||
|
||||
if (nBlkIndex != blocks.Count)
|
||||
{
|
||||
@ -74,7 +71,7 @@ namespace Ryujinx.Graphics.Shader.Decoders
|
||||
}
|
||||
}
|
||||
|
||||
FillBlock(code, currBlock, limitAddress, headerSize);
|
||||
FillBlock(gpuAccessor, currBlock, limitAddress, startAddress);
|
||||
|
||||
if (currBlock.OpCodes.Count != 0)
|
||||
{
|
||||
@ -82,11 +79,6 @@ namespace Ryujinx.Graphics.Shader.Decoders
|
||||
// including those from SSY/PBK instructions.
|
||||
foreach (OpCodePush pushOp in currBlock.PushOpCodes)
|
||||
{
|
||||
if (pushOp.GetAbsoluteAddress() >= maxAddress)
|
||||
{
|
||||
return null;
|
||||
}
|
||||
|
||||
GetBlock(pushOp.GetAbsoluteAddress());
|
||||
}
|
||||
|
||||
@ -98,11 +90,6 @@ namespace Ryujinx.Graphics.Shader.Decoders
|
||||
|
||||
if (lastOp is OpCodeBranch opBr)
|
||||
{
|
||||
if (opBr.GetAbsoluteAddress() >= maxAddress)
|
||||
{
|
||||
return null;
|
||||
}
|
||||
|
||||
currBlock.Branch = GetBlock(opBr.GetAbsoluteAddress());
|
||||
}
|
||||
else if (lastOp is OpCodeBranchIndir opBrIndir)
|
||||
@ -141,7 +128,7 @@ namespace Ryujinx.Graphics.Shader.Decoders
|
||||
}
|
||||
|
||||
// Do we have a block after the current one?
|
||||
if (!IsExit(currBlock.GetLastOp()) && currBlock.BrIndir != null && currBlock.EndAddress < maxAddress)
|
||||
if (!IsExit(currBlock.GetLastOp()) && currBlock.BrIndir != null)
|
||||
{
|
||||
bool targetVisited = visited.ContainsKey(currBlock.EndAddress);
|
||||
|
||||
@ -203,10 +190,10 @@ namespace Ryujinx.Graphics.Shader.Decoders
|
||||
}
|
||||
|
||||
private static void FillBlock(
|
||||
ReadOnlySpan<byte> code,
|
||||
Block block,
|
||||
ulong limitAddress,
|
||||
ulong startAddress)
|
||||
IGpuAccessor gpuAccessor,
|
||||
Block block,
|
||||
ulong limitAddress,
|
||||
ulong startAddress)
|
||||
{
|
||||
ulong address = block.Address;
|
||||
|
||||
@ -225,14 +212,11 @@ namespace Ryujinx.Graphics.Shader.Decoders
|
||||
continue;
|
||||
}
|
||||
|
||||
uint word0 = BinaryPrimitives.ReadUInt32LittleEndian(code.Slice((int)(startAddress + address)));
|
||||
uint word1 = BinaryPrimitives.ReadUInt32LittleEndian(code.Slice((int)(startAddress + address + 4)));
|
||||
|
||||
ulong opAddress = address;
|
||||
|
||||
address += 8;
|
||||
|
||||
long opCode = word0 | (long)word1 << 32;
|
||||
long opCode = gpuAccessor.MemoryRead<long>(startAddress + opAddress);
|
||||
|
||||
(InstEmitter emitter, OpCodeTable.OpActivator opActivator) = OpCodeTable.GetEmitter(opCode);
|
||||
|
||||
|
67
Ryujinx.Graphics.Shader/IGpuAccessor.cs
Normal file
67
Ryujinx.Graphics.Shader/IGpuAccessor.cs
Normal file
@ -0,0 +1,67 @@
|
||||
namespace Ryujinx.Graphics.Shader
|
||||
{
|
||||
public interface IGpuAccessor
|
||||
{
|
||||
public void Log(string message)
|
||||
{
|
||||
// No default log output.
|
||||
}
|
||||
|
||||
T MemoryRead<T>(ulong address) where T : unmanaged;
|
||||
|
||||
public int QueryComputeLocalSizeX()
|
||||
{
|
||||
return 1;
|
||||
}
|
||||
|
||||
public int QueryComputeLocalSizeY()
|
||||
{
|
||||
return 1;
|
||||
}
|
||||
|
||||
public int QueryComputeLocalSizeZ()
|
||||
{
|
||||
return 1;
|
||||
}
|
||||
|
||||
public int QueryComputeLocalMemorySize()
|
||||
{
|
||||
return 0x1000;
|
||||
}
|
||||
|
||||
public int QueryComputeSharedMemorySize()
|
||||
{
|
||||
return 0xc000;
|
||||
}
|
||||
|
||||
public bool QueryIsTextureBuffer(int handle)
|
||||
{
|
||||
return false;
|
||||
}
|
||||
|
||||
public bool QueryIsTextureRectangle(int handle)
|
||||
{
|
||||
return false;
|
||||
}
|
||||
|
||||
public InputTopology QueryPrimitiveTopology()
|
||||
{
|
||||
return InputTopology.Points;
|
||||
}
|
||||
|
||||
public int QueryStorageBufferOffsetAlignment()
|
||||
{
|
||||
return 16;
|
||||
}
|
||||
|
||||
public bool QuerySupportsNonConstantTextureOffset()
|
||||
{
|
||||
return true;
|
||||
}
|
||||
|
||||
public TextureFormat QueryTextureFormat(int handle)
|
||||
{
|
||||
return TextureFormat.R8G8B8A8Unorm;
|
||||
}
|
||||
}
|
||||
}
|
@ -72,7 +72,7 @@ namespace Ryujinx.Graphics.Shader.Instructions
|
||||
|
||||
if (intType == IntegerType.U64)
|
||||
{
|
||||
context.Config.PrintLog("Unimplemented 64-bits F2I.");
|
||||
context.Config.GpuAccessor.Log("Unimplemented 64-bits F2I.");
|
||||
|
||||
return;
|
||||
}
|
||||
@ -184,7 +184,7 @@ namespace Ryujinx.Graphics.Shader.Instructions
|
||||
|
||||
if (srcType == IntegerType.U64 || dstType == IntegerType.U64)
|
||||
{
|
||||
context.Config.PrintLog("Invalid I2I encoding.");
|
||||
context.Config.GpuAccessor.Log("Invalid I2I encoding.");
|
||||
|
||||
return;
|
||||
}
|
||||
|
@ -431,7 +431,7 @@ namespace Ryujinx.Graphics.Shader.Instructions
|
||||
|
||||
if (scale.AsFloat() == 1)
|
||||
{
|
||||
context.Config.PrintLog($"Invalid FP multiply scale \"{op.Scale}\".");
|
||||
context.Config.GpuAccessor.Log($"Invalid FP multiply scale \"{op.Scale}\".");
|
||||
}
|
||||
|
||||
if (isFP64)
|
||||
|
@ -88,7 +88,7 @@ namespace Ryujinx.Graphics.Shader.Instructions
|
||||
}
|
||||
else
|
||||
{
|
||||
context.Config.PrintLog($"Invalid barrier mode: {op.Mode}.");
|
||||
context.Config.GpuAccessor.Log($"Invalid barrier mode: {op.Mode}.");
|
||||
}
|
||||
}
|
||||
|
||||
@ -141,7 +141,7 @@ namespace Ryujinx.Graphics.Shader.Instructions
|
||||
|
||||
if (op.Size > IntegerSize.B64)
|
||||
{
|
||||
context.Config.PrintLog($"Invalid LDC size: {op.Size}.");
|
||||
context.Config.GpuAccessor.Log($"Invalid LDC size: {op.Size}.");
|
||||
}
|
||||
|
||||
bool isSmallInt = op.Size < IntegerSize.B32;
|
||||
@ -209,7 +209,7 @@ namespace Ryujinx.Graphics.Shader.Instructions
|
||||
|
||||
if (!(emit || cut))
|
||||
{
|
||||
context.Config.PrintLog("Invalid OUT encoding.");
|
||||
context.Config.GpuAccessor.Log("Invalid OUT encoding.");
|
||||
}
|
||||
|
||||
if (emit)
|
||||
@ -274,7 +274,7 @@ namespace Ryujinx.Graphics.Shader.Instructions
|
||||
}
|
||||
else
|
||||
{
|
||||
context.Config.PrintLog($"Invalid reduction type: {type}.");
|
||||
context.Config.GpuAccessor.Log($"Invalid reduction type: {type}.");
|
||||
}
|
||||
break;
|
||||
case AtomicOp.BitwiseAnd:
|
||||
@ -284,7 +284,7 @@ namespace Ryujinx.Graphics.Shader.Instructions
|
||||
}
|
||||
else
|
||||
{
|
||||
context.Config.PrintLog($"Invalid reduction type: {type}.");
|
||||
context.Config.GpuAccessor.Log($"Invalid reduction type: {type}.");
|
||||
}
|
||||
break;
|
||||
case AtomicOp.BitwiseExclusiveOr:
|
||||
@ -294,7 +294,7 @@ namespace Ryujinx.Graphics.Shader.Instructions
|
||||
}
|
||||
else
|
||||
{
|
||||
context.Config.PrintLog($"Invalid reduction type: {type}.");
|
||||
context.Config.GpuAccessor.Log($"Invalid reduction type: {type}.");
|
||||
}
|
||||
break;
|
||||
case AtomicOp.BitwiseOr:
|
||||
@ -304,7 +304,7 @@ namespace Ryujinx.Graphics.Shader.Instructions
|
||||
}
|
||||
else
|
||||
{
|
||||
context.Config.PrintLog($"Invalid reduction type: {type}.");
|
||||
context.Config.GpuAccessor.Log($"Invalid reduction type: {type}.");
|
||||
}
|
||||
break;
|
||||
case AtomicOp.Maximum:
|
||||
@ -318,7 +318,7 @@ namespace Ryujinx.Graphics.Shader.Instructions
|
||||
}
|
||||
else
|
||||
{
|
||||
context.Config.PrintLog($"Invalid reduction type: {type}.");
|
||||
context.Config.GpuAccessor.Log($"Invalid reduction type: {type}.");
|
||||
}
|
||||
break;
|
||||
case AtomicOp.Minimum:
|
||||
@ -332,7 +332,7 @@ namespace Ryujinx.Graphics.Shader.Instructions
|
||||
}
|
||||
else
|
||||
{
|
||||
context.Config.PrintLog($"Invalid reduction type: {type}.");
|
||||
context.Config.GpuAccessor.Log($"Invalid reduction type: {type}.");
|
||||
}
|
||||
break;
|
||||
}
|
||||
@ -346,7 +346,7 @@ namespace Ryujinx.Graphics.Shader.Instructions
|
||||
|
||||
if (op.Size > IntegerSize.B128)
|
||||
{
|
||||
context.Config.PrintLog($"Invalid load size: {op.Size}.");
|
||||
context.Config.GpuAccessor.Log($"Invalid load size: {op.Size}.");
|
||||
}
|
||||
|
||||
bool isSmallInt = op.Size < IntegerSize.B32;
|
||||
@ -432,7 +432,7 @@ namespace Ryujinx.Graphics.Shader.Instructions
|
||||
|
||||
if (op.Size > IntegerSize.B128)
|
||||
{
|
||||
context.Config.PrintLog($"Invalid store size: {op.Size}.");
|
||||
context.Config.GpuAccessor.Log($"Invalid store size: {op.Size}.");
|
||||
}
|
||||
|
||||
bool isSmallInt = op.Size < IntegerSize.B32;
|
||||
|
@ -32,7 +32,7 @@ namespace Ryujinx.Graphics.Shader.Instructions
|
||||
if (isCC)
|
||||
{
|
||||
// TODO: Support Register to condition code flags copy.
|
||||
context.Config.PrintLog("R2P.CC not implemented.");
|
||||
context.Config.GpuAccessor.Log("R2P.CC not implemented.");
|
||||
}
|
||||
else
|
||||
{
|
||||
|
@ -19,7 +19,7 @@ namespace Ryujinx.Graphics.Shader.Instructions
|
||||
|
||||
if (type == SamplerType.None)
|
||||
{
|
||||
context.Config.PrintLog("Invalid image store sampler type.");
|
||||
context.Config.GpuAccessor.Log("Invalid image store sampler type.");
|
||||
|
||||
return;
|
||||
}
|
||||
@ -158,7 +158,7 @@ namespace Ryujinx.Graphics.Shader.Instructions
|
||||
|
||||
if (type == SamplerType.None)
|
||||
{
|
||||
context.Config.PrintLog("Invalid image store sampler type.");
|
||||
context.Config.GpuAccessor.Log("Invalid image store sampler type.");
|
||||
|
||||
return;
|
||||
}
|
||||
@ -344,7 +344,7 @@ namespace Ryujinx.Graphics.Shader.Instructions
|
||||
|
||||
if (type == SamplerType.None)
|
||||
{
|
||||
context.Config.PrintLog("Invalid texture sampler type.");
|
||||
context.Config.GpuAccessor.Log("Invalid texture sampler type.");
|
||||
|
||||
return;
|
||||
}
|
||||
@ -423,14 +423,14 @@ namespace Ryujinx.Graphics.Shader.Instructions
|
||||
|
||||
if (type == SamplerType.None)
|
||||
{
|
||||
context.Config.PrintLog("Invalid texel fetch sampler type.");
|
||||
context.Config.GpuAccessor.Log("Invalid texel fetch sampler type.");
|
||||
|
||||
return;
|
||||
}
|
||||
|
||||
flags = ConvertTextureFlags(tldsOp.Target) | TextureFlags.IntCoords;
|
||||
|
||||
if (tldsOp.Target == TexelLoadTarget.Texture1DLodZero && context.Config.QueryInfoBool(QueryInfoName.IsTextureBuffer, tldsOp.Immediate))
|
||||
if (tldsOp.Target == TexelLoadTarget.Texture1DLodZero && context.Config.GpuAccessor.QueryIsTextureBuffer(tldsOp.Immediate))
|
||||
{
|
||||
type = SamplerType.TextureBuffer;
|
||||
flags &= ~TextureFlags.LodLevel;
|
||||
@ -1020,7 +1020,7 @@ namespace Ryujinx.Graphics.Shader.Instructions
|
||||
|
||||
if (type == SamplerType.Texture1D && flags == TextureFlags.IntCoords && !isBindless)
|
||||
{
|
||||
bool isTypeBuffer = context.Config.QueryInfoBool(QueryInfoName.IsTextureBuffer, op.Immediate);
|
||||
bool isTypeBuffer = context.Config.GpuAccessor.QueryIsTextureBuffer(op.Immediate);
|
||||
|
||||
if (isTypeBuffer)
|
||||
{
|
||||
@ -1093,11 +1093,11 @@ namespace Ryujinx.Graphics.Shader.Instructions
|
||||
|
||||
private static TextureFormat GetTextureFormat(EmitterContext context, int handle)
|
||||
{
|
||||
var format = (TextureFormat)context.Config.QueryInfo(QueryInfoName.TextureFormat, handle);
|
||||
var format = context.Config.GpuAccessor.QueryTextureFormat(handle);
|
||||
|
||||
if (format == TextureFormat.Unknown)
|
||||
{
|
||||
context.Config.PrintLog($"Unknown format for texture {handle}.");
|
||||
context.Config.GpuAccessor.Log($"Unknown format for texture {handle}.");
|
||||
|
||||
format = TextureFormat.R8G8B8A8Unorm;
|
||||
}
|
||||
|
@ -36,7 +36,7 @@ namespace Ryujinx.Graphics.Shader.Instructions
|
||||
}
|
||||
else
|
||||
{
|
||||
context.Config.PrintLog($"Invalid vote operation: {op.VoteOp}.");
|
||||
context.Config.GpuAccessor.Log($"Invalid vote operation: {op.VoteOp}.");
|
||||
}
|
||||
|
||||
if (!op.Rd.IsRZ)
|
||||
|
@ -1,17 +0,0 @@
|
||||
namespace Ryujinx.Graphics.Shader
|
||||
{
|
||||
public enum QueryInfoName
|
||||
{
|
||||
ComputeLocalSizeX,
|
||||
ComputeLocalSizeY,
|
||||
ComputeLocalSizeZ,
|
||||
ComputeLocalMemorySize,
|
||||
ComputeSharedMemorySize,
|
||||
IsTextureBuffer,
|
||||
IsTextureRectangle,
|
||||
PrimitiveTopology,
|
||||
StorageBufferOffsetAlignment,
|
||||
SupportsNonConstantTextureOffset,
|
||||
TextureFormat
|
||||
}
|
||||
}
|
@ -10,13 +10,15 @@ namespace Ryujinx.Graphics.Shader
|
||||
|
||||
public string Code { get; private set; }
|
||||
|
||||
public int SizeA { get; }
|
||||
public int Size { get; }
|
||||
|
||||
internal ShaderProgram(ShaderProgramInfo info, ShaderStage stage, string code, int size)
|
||||
internal ShaderProgram(ShaderProgramInfo info, ShaderStage stage, string code, int size, int sizeA)
|
||||
{
|
||||
Info = info;
|
||||
Stage = stage;
|
||||
Code = code;
|
||||
SizeA = sizeA;
|
||||
Size = size;
|
||||
}
|
||||
|
||||
|
@ -79,7 +79,7 @@ namespace Ryujinx.Graphics.Shader.Translation
|
||||
sbSlot = PrependOperation(Instruction.ConditionalSelect, inRange, Const(slot), sbSlot);
|
||||
}
|
||||
|
||||
Operand alignMask = Const(-config.QueryInfo(QueryInfoName.StorageBufferOffsetAlignment));
|
||||
Operand alignMask = Const(-config.GpuAccessor.QueryStorageBufferOffsetAlignment());
|
||||
|
||||
Operand baseAddrTrunc = PrependOperation(Instruction.BitwiseAnd, sbBaseAddrLow, alignMask);
|
||||
Operand byteOffset = PrependOperation(Instruction.Subtract, addrLow, baseAddrTrunc);
|
||||
@ -131,9 +131,9 @@ namespace Ryujinx.Graphics.Shader.Translation
|
||||
bool hasOffset = (texOp.Flags & TextureFlags.Offset) != 0;
|
||||
bool hasOffsets = (texOp.Flags & TextureFlags.Offsets) != 0;
|
||||
|
||||
bool hasInvalidOffset = (hasOffset || hasOffsets) && !config.QueryInfoBool(QueryInfoName.SupportsNonConstantTextureOffset);
|
||||
bool hasInvalidOffset = (hasOffset || hasOffsets) && !config.GpuAccessor.QuerySupportsNonConstantTextureOffset();
|
||||
|
||||
bool isRect = config.QueryInfoBool(QueryInfoName.IsTextureRectangle, texOp.Handle);
|
||||
bool isRect = config.GpuAccessor.QueryIsTextureRectangle(texOp.Handle);
|
||||
|
||||
if (!(hasInvalidOffset || isRect))
|
||||
{
|
||||
|
@ -69,7 +69,7 @@ namespace Ryujinx.Graphics.Shader.Translation.Optimizations
|
||||
|
||||
Operand baseAddrTrunc = Local();
|
||||
|
||||
Operand alignMask = Const(-config.QueryInfo(QueryInfoName.StorageBufferOffsetAlignment));
|
||||
Operand alignMask = Const(-config.GpuAccessor.QueryStorageBufferOffsetAlignment());
|
||||
|
||||
Operation andOp = new Operation(Instruction.BitwiseAnd, baseAddrTrunc, baseAddrLow, alignMask);
|
||||
|
||||
@ -140,7 +140,7 @@ namespace Ryujinx.Graphics.Shader.Translation.Optimizations
|
||||
|
||||
Operand baseAddrTrunc = Local();
|
||||
|
||||
Operand alignMask = Const(-config.QueryInfo(QueryInfoName.StorageBufferOffsetAlignment));
|
||||
Operand alignMask = Const(-config.GpuAccessor.QueryStorageBufferOffsetAlignment());
|
||||
|
||||
Operation andOp = new Operation(Instruction.BitwiseAnd, baseAddrTrunc, baseAddrLow, alignMask);
|
||||
|
||||
|
@ -18,11 +18,11 @@ namespace Ryujinx.Graphics.Shader.Translation
|
||||
public bool OmapSampleMask { get; }
|
||||
public bool OmapDepth { get; }
|
||||
|
||||
public IGpuAccessor GpuAccessor { get; }
|
||||
|
||||
public TranslationFlags Flags { get; }
|
||||
|
||||
private TranslatorCallbacks _callbacks;
|
||||
|
||||
public ShaderConfig(TranslationFlags flags, TranslatorCallbacks callbacks)
|
||||
public ShaderConfig(IGpuAccessor gpuAccessor, TranslationFlags flags)
|
||||
{
|
||||
Stage = ShaderStage.Compute;
|
||||
OutputTopology = OutputTopology.PointList;
|
||||
@ -32,11 +32,11 @@ namespace Ryujinx.Graphics.Shader.Translation
|
||||
OmapTargets = null;
|
||||
OmapSampleMask = false;
|
||||
OmapDepth = false;
|
||||
GpuAccessor = gpuAccessor;
|
||||
Flags = flags;
|
||||
_callbacks = callbacks;
|
||||
}
|
||||
|
||||
public ShaderConfig(ShaderHeader header, TranslationFlags flags, TranslatorCallbacks callbacks)
|
||||
public ShaderConfig(ShaderHeader header, IGpuAccessor gpuAccessor, TranslationFlags flags)
|
||||
{
|
||||
Stage = header.Stage;
|
||||
OutputTopology = header.OutputTopology;
|
||||
@ -46,8 +46,8 @@ namespace Ryujinx.Graphics.Shader.Translation
|
||||
OmapTargets = header.OmapTargets;
|
||||
OmapSampleMask = header.OmapSampleMask;
|
||||
OmapDepth = header.OmapDepth;
|
||||
GpuAccessor = gpuAccessor;
|
||||
Flags = flags;
|
||||
_callbacks = callbacks;
|
||||
}
|
||||
|
||||
public int GetDepthRegister()
|
||||
@ -68,51 +68,5 @@ namespace Ryujinx.Graphics.Shader.Translation
|
||||
// The depth register is always two registers after the last color output.
|
||||
return count + 1;
|
||||
}
|
||||
|
||||
public bool QueryInfoBool(QueryInfoName info, int index = 0)
|
||||
{
|
||||
return Convert.ToBoolean(QueryInfo(info, index));
|
||||
}
|
||||
|
||||
public int QueryInfo(QueryInfoName info, int index = 0)
|
||||
{
|
||||
if (_callbacks.QueryInfo != null)
|
||||
{
|
||||
return _callbacks.QueryInfo(info, index);
|
||||
}
|
||||
else
|
||||
{
|
||||
switch (info)
|
||||
{
|
||||
case QueryInfoName.ComputeLocalSizeX:
|
||||
case QueryInfoName.ComputeLocalSizeY:
|
||||
case QueryInfoName.ComputeLocalSizeZ:
|
||||
return 1;
|
||||
case QueryInfoName.ComputeLocalMemorySize:
|
||||
return 0x1000;
|
||||
case QueryInfoName.ComputeSharedMemorySize:
|
||||
return 0xc000;
|
||||
case QueryInfoName.IsTextureBuffer:
|
||||
return Convert.ToInt32(false);
|
||||
case QueryInfoName.IsTextureRectangle:
|
||||
return Convert.ToInt32(false);
|
||||
case QueryInfoName.PrimitiveTopology:
|
||||
return (int)InputTopology.Points;
|
||||
case QueryInfoName.StorageBufferOffsetAlignment:
|
||||
return 16;
|
||||
case QueryInfoName.SupportsNonConstantTextureOffset:
|
||||
return Convert.ToInt32(true);
|
||||
case QueryInfoName.TextureFormat:
|
||||
return (int)TextureFormat.R8G8B8A8Unorm;
|
||||
}
|
||||
}
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
public void PrintLog(string message)
|
||||
{
|
||||
_callbacks.PrintLog?.Invoke(message);
|
||||
}
|
||||
}
|
||||
}
|
@ -1,6 +1,5 @@
|
||||
using Ryujinx.Graphics.Shader.Decoders;
|
||||
using System;
|
||||
using System.Runtime.InteropServices;
|
||||
|
||||
namespace Ryujinx.Graphics.Shader.Translation
|
||||
{
|
||||
@ -110,15 +109,13 @@ namespace Ryujinx.Graphics.Shader.Translation
|
||||
public bool OmapSampleMask { get; }
|
||||
public bool OmapDepth { get; }
|
||||
|
||||
public ShaderHeader(ReadOnlySpan<byte> code)
|
||||
public ShaderHeader(IGpuAccessor gpuAccessor, ulong address)
|
||||
{
|
||||
ReadOnlySpan<int> header = MemoryMarshal.Cast<byte, int>(code);
|
||||
|
||||
int commonWord0 = header[0];
|
||||
int commonWord1 = header[1];
|
||||
int commonWord2 = header[2];
|
||||
int commonWord3 = header[3];
|
||||
int commonWord4 = header[4];
|
||||
int commonWord0 = gpuAccessor.MemoryRead<int>(address + 0);
|
||||
int commonWord1 = gpuAccessor.MemoryRead<int>(address + 4);
|
||||
int commonWord2 = gpuAccessor.MemoryRead<int>(address + 8);
|
||||
int commonWord3 = gpuAccessor.MemoryRead<int>(address + 12);
|
||||
int commonWord4 = gpuAccessor.MemoryRead<int>(address + 16);
|
||||
|
||||
SphType = commonWord0.Extract(0, 5);
|
||||
Version = commonWord0.Extract(5, 5);
|
||||
@ -163,22 +160,19 @@ namespace Ryujinx.Graphics.Shader.Translation
|
||||
|
||||
ImapTypes = new ImapPixelType[32];
|
||||
|
||||
for (int i = 0; i < 8; i++)
|
||||
for (ulong i = 0; i < 32; i++)
|
||||
{
|
||||
for (int j = 0; j < 4; j++)
|
||||
{
|
||||
byte imap = (byte)(header[6 + i] >> (j * 8));
|
||||
byte imap = gpuAccessor.MemoryRead<byte>(address + 0x18 + i);
|
||||
|
||||
ImapTypes[i * 4 + j] = new ImapPixelType(
|
||||
(PixelImap)((imap >> 0) & 3),
|
||||
(PixelImap)((imap >> 2) & 3),
|
||||
(PixelImap)((imap >> 4) & 3),
|
||||
(PixelImap)((imap >> 6) & 3));
|
||||
}
|
||||
ImapTypes[i] = new ImapPixelType(
|
||||
(PixelImap)((imap >> 0) & 3),
|
||||
(PixelImap)((imap >> 2) & 3),
|
||||
(PixelImap)((imap >> 4) & 3),
|
||||
(PixelImap)((imap >> 6) & 3));
|
||||
}
|
||||
|
||||
int type2OmapTarget = header[18];
|
||||
int type2Omap = header[19];
|
||||
int type2OmapTarget = gpuAccessor.MemoryRead<int>(address + 0x48);
|
||||
int type2Omap = gpuAccessor.MemoryRead<int>(address + 0x4c);
|
||||
|
||||
OmapTargets = new OmapTarget[8];
|
||||
|
||||
|
@ -14,46 +14,22 @@ namespace Ryujinx.Graphics.Shader.Translation
|
||||
{
|
||||
private const int HeaderSize = 0x50;
|
||||
|
||||
public static ReadOnlySpan<byte> ExtractCode(ReadOnlySpan<byte> code, bool compute, out int headerSize)
|
||||
public static ShaderProgram Translate(ulong address, IGpuAccessor gpuAccessor, TranslationFlags flags)
|
||||
{
|
||||
headerSize = compute ? 0 : HeaderSize;
|
||||
|
||||
Block[] cfg = Decoder.Decode(code, (ulong)headerSize);
|
||||
|
||||
if (cfg == null)
|
||||
{
|
||||
return code;
|
||||
}
|
||||
|
||||
ulong endAddress = 0;
|
||||
|
||||
foreach (Block block in cfg)
|
||||
{
|
||||
if (endAddress < block.EndAddress)
|
||||
{
|
||||
endAddress = block.EndAddress;
|
||||
}
|
||||
}
|
||||
|
||||
return code.Slice(0, headerSize + (int)endAddress);
|
||||
}
|
||||
|
||||
public static ShaderProgram Translate(ReadOnlySpan<byte> code, TranslatorCallbacks callbacks, TranslationFlags flags)
|
||||
{
|
||||
Operation[] ops = DecodeShader(code, callbacks, flags, out ShaderConfig config, out int size);
|
||||
Operation[] ops = DecodeShader(address, gpuAccessor, flags, out ShaderConfig config, out int size);
|
||||
|
||||
return Translate(ops, config, size);
|
||||
}
|
||||
|
||||
public static ShaderProgram Translate(ReadOnlySpan<byte> vpACode, ReadOnlySpan<byte> vpBCode, TranslatorCallbacks callbacks, TranslationFlags flags)
|
||||
public static ShaderProgram Translate(ulong addressA, ulong addressB, IGpuAccessor gpuAccessor, TranslationFlags flags)
|
||||
{
|
||||
Operation[] vpAOps = DecodeShader(vpACode, callbacks, flags, out _, out _);
|
||||
Operation[] vpBOps = DecodeShader(vpBCode, callbacks, flags, out ShaderConfig config, out int sizeB);
|
||||
Operation[] opsA = DecodeShader(addressA, gpuAccessor, flags, out _, out int sizeA);
|
||||
Operation[] opsB = DecodeShader(addressB, gpuAccessor, flags, out ShaderConfig config, out int sizeB);
|
||||
|
||||
return Translate(Combine(vpAOps, vpBOps), config, sizeB);
|
||||
return Translate(Combine(opsA, opsB), config, sizeB, sizeA);
|
||||
}
|
||||
|
||||
private static ShaderProgram Translate(Operation[] ops, ShaderConfig config, int size)
|
||||
private static ShaderProgram Translate(Operation[] ops, ShaderConfig config, int size, int sizeA = 0)
|
||||
{
|
||||
BasicBlock[] blocks = ControlFlowGraph.MakeCfg(ops);
|
||||
|
||||
@ -83,34 +59,34 @@ namespace Ryujinx.Graphics.Shader.Translation
|
||||
|
||||
string glslCode = program.Code;
|
||||
|
||||
return new ShaderProgram(spInfo, config.Stage, glslCode, size);
|
||||
return new ShaderProgram(spInfo, config.Stage, glslCode, size, sizeA);
|
||||
}
|
||||
|
||||
private static Operation[] DecodeShader(
|
||||
ReadOnlySpan<byte> code,
|
||||
TranslatorCallbacks callbacks,
|
||||
TranslationFlags flags,
|
||||
out ShaderConfig config,
|
||||
out int size)
|
||||
ulong address,
|
||||
IGpuAccessor gpuAccessor,
|
||||
TranslationFlags flags,
|
||||
out ShaderConfig config,
|
||||
out int size)
|
||||
{
|
||||
Block[] cfg;
|
||||
|
||||
if ((flags & TranslationFlags.Compute) != 0)
|
||||
{
|
||||
config = new ShaderConfig(flags, callbacks);
|
||||
config = new ShaderConfig(gpuAccessor, flags);
|
||||
|
||||
cfg = Decoder.Decode(code, 0);
|
||||
cfg = Decoder.Decode(gpuAccessor, address);
|
||||
}
|
||||
else
|
||||
{
|
||||
config = new ShaderConfig(new ShaderHeader(code), flags, callbacks);
|
||||
config = new ShaderConfig(new ShaderHeader(gpuAccessor, address), gpuAccessor, flags);
|
||||
|
||||
cfg = Decoder.Decode(code, HeaderSize);
|
||||
cfg = Decoder.Decode(gpuAccessor, address + HeaderSize);
|
||||
}
|
||||
|
||||
if (cfg == null)
|
||||
{
|
||||
config.PrintLog("Invalid branch detected, failed to build CFG.");
|
||||
gpuAccessor.Log("Invalid branch detected, failed to build CFG.");
|
||||
|
||||
size = 0;
|
||||
|
||||
@ -150,7 +126,7 @@ namespace Ryujinx.Graphics.Shader.Translation
|
||||
{
|
||||
instName = "???";
|
||||
|
||||
config.PrintLog($"Invalid instruction at 0x{op.Address:X6} (0x{op.RawOpCode:X16}).");
|
||||
gpuAccessor.Log($"Invalid instruction at 0x{op.Address:X6} (0x{op.RawOpCode:X16}).");
|
||||
}
|
||||
|
||||
string dbgComment = $"0x{op.Address:X6}: 0x{op.RawOpCode:X16} {instName}";
|
||||
|
@ -1,17 +0,0 @@
|
||||
using System;
|
||||
|
||||
namespace Ryujinx.Graphics.Shader.Translation
|
||||
{
|
||||
public struct TranslatorCallbacks
|
||||
{
|
||||
internal Func<QueryInfoName, int, int> QueryInfo { get; }
|
||||
|
||||
internal Action<string> PrintLog { get; }
|
||||
|
||||
public TranslatorCallbacks(Func<QueryInfoName, int, int> queryInfoCallback, Action<string> printLogCallback)
|
||||
{
|
||||
QueryInfo = queryInfoCallback;
|
||||
PrintLog = printLogCallback;
|
||||
}
|
||||
}
|
||||
}
|
@ -2,11 +2,27 @@
|
||||
using Ryujinx.Graphics.Shader.Translation;
|
||||
using System;
|
||||
using System.IO;
|
||||
using System.Runtime.InteropServices;
|
||||
|
||||
namespace Ryujinx.ShaderTools
|
||||
{
|
||||
class Program
|
||||
{
|
||||
private class GpuAccessor : IGpuAccessor
|
||||
{
|
||||
private readonly byte[] _data;
|
||||
|
||||
public GpuAccessor(byte[] data)
|
||||
{
|
||||
_data = data;
|
||||
}
|
||||
|
||||
public T MemoryRead<T>(ulong address) where T : unmanaged
|
||||
{
|
||||
return MemoryMarshal.Cast<byte, T>(new ReadOnlySpan<byte>(_data).Slice((int)address))[0];
|
||||
}
|
||||
}
|
||||
|
||||
static void Main(string[] args)
|
||||
{
|
||||
if (args.Length == 1 || args.Length == 2)
|
||||
@ -20,7 +36,7 @@ namespace Ryujinx.ShaderTools
|
||||
|
||||
byte[] data = File.ReadAllBytes(args[^1]);
|
||||
|
||||
string code = Translator.Translate(data, new TranslatorCallbacks(null, null), flags).Code;
|
||||
string code = Translator.Translate(0, new GpuAccessor(data), flags).Code;
|
||||
|
||||
Console.WriteLine(code);
|
||||
}
|
||||
|
Loading…
Reference in New Issue
Block a user