diff --git a/Ryujinx.Graphics.GAL/Capabilities.cs b/Ryujinx.Graphics.GAL/Capabilities.cs
index 246722f81..4a8b7c83b 100644
--- a/Ryujinx.Graphics.GAL/Capabilities.cs
+++ b/Ryujinx.Graphics.GAL/Capabilities.cs
@@ -4,13 +4,16 @@ namespace Ryujinx.Graphics.GAL
{
public bool SupportsAstcCompression { get; }
+ public int MaximumViewportDimensions { get; }
public int StorageBufferOffsetAlignment { get; }
public Capabilities(
bool supportsAstcCompression,
+ int maximumViewportDimensions,
int storageBufferOffsetAlignment)
{
SupportsAstcCompression = supportsAstcCompression;
+ MaximumViewportDimensions = maximumViewportDimensions;
StorageBufferOffsetAlignment = storageBufferOffsetAlignment;
}
}
diff --git a/Ryujinx.Graphics.Gpu/Engine/MethodClear.cs b/Ryujinx.Graphics.Gpu/Engine/MethodClear.cs
index da6c94e57..43f8b25db 100644
--- a/Ryujinx.Graphics.Gpu/Engine/MethodClear.cs
+++ b/Ryujinx.Graphics.Gpu/Engine/MethodClear.cs
@@ -7,7 +7,7 @@ namespace Ryujinx.Graphics.Gpu.Engine
{
private void Clear(GpuState state, int argument)
{
- UpdateRenderTargetStateIfNeeded(state);
+ UpdateRenderTargetState(state, useControl: false);
_textureManager.CommitGraphicsBindings();
@@ -49,6 +49,8 @@ namespace Ryujinx.Graphics.Gpu.Engine
stencilValue,
stencilMask);
}
+
+ UpdateRenderTargetState(state, useControl: true);
}
}
}
\ No newline at end of file
diff --git a/Ryujinx.Graphics.Gpu/Engine/MethodDraw.cs b/Ryujinx.Graphics.Gpu/Engine/MethodDraw.cs
index d69b9ea03..b7e8a64b2 100644
--- a/Ryujinx.Graphics.Gpu/Engine/MethodDraw.cs
+++ b/Ryujinx.Graphics.Gpu/Engine/MethodDraw.cs
@@ -10,7 +10,7 @@ namespace Ryujinx.Graphics.Gpu.Engine
private int _firstIndex;
private int _indexCount;
- private bool _instancedHasState;
+ private bool _instancedDrawPending;
private bool _instancedIndexed;
private int _instancedFirstIndex;
@@ -32,9 +32,9 @@ namespace Ryujinx.Graphics.Gpu.Engine
if (instanced)
{
- if (!_instancedHasState)
+ if (!_instancedDrawPending)
{
- _instancedHasState = true;
+ _instancedDrawPending = true;
_instancedIndexed = _drawIndexed;
@@ -82,20 +82,22 @@ namespace Ryujinx.Graphics.Gpu.Engine
private void DrawBegin(GpuState state, int argument)
{
- PrimitiveType type = (PrimitiveType)(argument & 0xffff);
-
- _context.Renderer.Pipeline.SetPrimitiveTopology(type.Convert());
-
- PrimitiveType = type;
-
if ((argument & (1 << 26)) != 0)
{
_instanceIndex++;
}
else if ((argument & (1 << 27)) == 0)
{
+ PerformDeferredDraws();
+
_instanceIndex = 0;
}
+
+ PrimitiveType type = (PrimitiveType)(argument & 0xffff);
+
+ _context.Renderer.Pipeline.SetPrimitiveTopology(type.Convert());
+
+ PrimitiveType = type;
}
private void SetIndexBufferCount(GpuState state, int argument)
@@ -106,9 +108,9 @@ namespace Ryujinx.Graphics.Gpu.Engine
public void PerformDeferredDraws()
{
// Perform any pending instanced draw.
- if (_instancedHasState)
+ if (_instancedDrawPending)
{
- _instancedHasState = false;
+ _instancedDrawPending = false;
if (_instancedIndexed)
{
diff --git a/Ryujinx.Graphics.Gpu/Engine/MethodUniformBufferUpdate.cs b/Ryujinx.Graphics.Gpu/Engine/MethodUniformBufferUpdate.cs
index 12d44f511..43bab2433 100644
--- a/Ryujinx.Graphics.Gpu/Engine/MethodUniformBufferUpdate.cs
+++ b/Ryujinx.Graphics.Gpu/Engine/MethodUniformBufferUpdate.cs
@@ -1,4 +1,3 @@
-using Ryujinx.Graphics.Gpu.Memory;
using Ryujinx.Graphics.Gpu.State;
namespace Ryujinx.Graphics.Gpu.Engine
@@ -9,11 +8,6 @@ namespace Ryujinx.Graphics.Gpu.Engine
{
var uniformBuffer = state.Get<UniformBufferState>(MethodOffset.UniformBufferState);
- if (_context.MemoryManager.Translate(uniformBuffer.Address.Pack() + (uint)uniformBuffer.Offset) == MemoryManager.BadAddress)
- {
- return;
- }
-
_context.MemoryAccessor.Write(uniformBuffer.Address.Pack() + (uint)uniformBuffer.Offset, argument);
state.SetUniformBufferOffset(uniformBuffer.Offset + 4);
diff --git a/Ryujinx.Graphics.Gpu/Engine/Methods.cs b/Ryujinx.Graphics.Gpu/Engine/Methods.cs
index 18fd7e708..5388c86d5 100644
--- a/Ryujinx.Graphics.Gpu/Engine/Methods.cs
+++ b/Ryujinx.Graphics.Gpu/Engine/Methods.cs
@@ -86,7 +86,14 @@ namespace Ryujinx.Graphics.Gpu.Engine
UpdateShaderState(state);
}
- UpdateRenderTargetStateIfNeeded(state);
+ if (state.QueryModified(MethodOffset.RtColorState,
+ MethodOffset.RtDepthStencilState,
+ MethodOffset.RtControl,
+ MethodOffset.RtDepthStencilSize,
+ MethodOffset.RtDepthStencilEnable))
+ {
+ UpdateRenderTargetState(state, useControl: true);
+ }
if (state.QueryModified(MethodOffset.DepthTestEnable,
MethodOffset.DepthWriteEnable,
@@ -155,7 +162,7 @@ namespace Ryujinx.Graphics.Gpu.Engine
UpdateFaceState(state);
}
- if (state.QueryModified(MethodOffset.RtColorMask))
+ if (state.QueryModified(MethodOffset.RtColorMaskShared, MethodOffset.RtColorMask))
{
UpdateRtColorMask(state);
}
@@ -210,19 +217,12 @@ namespace Ryujinx.Graphics.Gpu.Engine
}
}
- private void UpdateRenderTargetStateIfNeeded(GpuState state)
+ private void UpdateRenderTargetState(GpuState state, bool useControl)
{
- if (state.QueryModified(MethodOffset.RtColorState,
- MethodOffset.RtDepthStencilState,
- MethodOffset.RtDepthStencilSize,
- MethodOffset.RtDepthStencilEnable))
- {
- UpdateRenderTargetState(state);
- }
- }
+ var rtControl = state.Get<RtControl>(MethodOffset.RtControl);
+
+ int count = useControl ? rtControl.UnpackCount() : Constants.TotalRenderTargets;
- private void UpdateRenderTargetState(GpuState state)
- {
var msaaMode = state.Get<TextureMsaaMode>(MethodOffset.RtMsaaMode);
int samplesInX = msaaMode.SamplesInX();
@@ -230,9 +230,11 @@ namespace Ryujinx.Graphics.Gpu.Engine
for (int index = 0; index < Constants.TotalRenderTargets; index++)
{
- var colorState = state.Get<RtColorState>(MethodOffset.RtColorState, index);
+ int rtIndex = useControl ? rtControl.UnpackPermutationIndex(index) : index;
- if (!IsRtEnabled(colorState))
+ var colorState = state.Get<RtColorState>(MethodOffset.RtColorState, rtIndex);
+
+ if (index >= count || !IsRtEnabled(colorState))
{
_textureManager.SetRenderTargetColor(index, null);
@@ -292,6 +294,8 @@ namespace Ryujinx.Graphics.Gpu.Engine
private void UpdateViewportTransform(GpuState state)
{
+ bool transformEnable = GetViewportTransformEnable(state);
+
bool flipY = (state.Get<int>(MethodOffset.YControl) & 1) != 0;
float yFlip = flipY ? -1 : 1;
@@ -303,13 +307,35 @@ namespace Ryujinx.Graphics.Gpu.Engine
var transform = state.Get<ViewportTransform>(MethodOffset.ViewportTransform, index);
var extents = state.Get<ViewportExtents> (MethodOffset.ViewportExtents, index);
- float x = transform.TranslateX - MathF.Abs(transform.ScaleX);
- float y = transform.TranslateY - MathF.Abs(transform.ScaleY);
+ RectangleF region;
- float width = transform.ScaleX * 2;
- float height = transform.ScaleY * 2 * yFlip;
+ if (transformEnable)
+ {
+ float x = transform.TranslateX - MathF.Abs(transform.ScaleX);
+ float y = transform.TranslateY - MathF.Abs(transform.ScaleY);
- RectangleF region = new RectangleF(x, y, width, height);
+ float width = transform.ScaleX * 2;
+ float height = transform.ScaleY * 2 * yFlip;
+
+ region = new RectangleF(x, y, width, height);
+ }
+ else
+ {
+ // It's not possible to fully disable viewport transform, at least with the most
+ // common graphics APIs, but we can effectively disable it with a dummy transform.
+ // The transform is defined as: xw = (width / 2) * xndc + x + (width / 2)
+ // By setting x to -(width / 2), we effectively remove the translation.
+ // By setting the width to 2, we remove the scale since 2 / 2 = 1.
+ // Now, the only problem is the viewport clipping, that we also can't disable.
+ // To prevent the values from being clipped, we multiply (-1, -1, 2, 2) by
+ // the maximum supported viewport dimensions.
+ // This must be compensated on the shader, by dividing the vertex position
+ // by the maximum viewport dimensions.
+ float maxSize = (float)_context.Capabilities.MaximumViewportDimensions;
+ float halfMaxSize = (float)_context.Capabilities.MaximumViewportDimensions * 0.5f;
+
+ region = new RectangleF(-halfMaxSize, -halfMaxSize, maxSize, maxSize * yFlip);
+ }
viewports[index] = new Viewport(
region,
@@ -537,11 +563,13 @@ namespace Ryujinx.Graphics.Gpu.Engine
private void UpdateRtColorMask(GpuState state)
{
+ bool rtColorMaskShared = state.Get<Boolean32>(MethodOffset.RtColorMaskShared);
+
uint[] componentMasks = new uint[Constants.TotalRenderTargets];
for (int index = 0; index < Constants.TotalRenderTargets; index++)
{
- var colorMask = state.Get<RtColorMask>(MethodOffset.RtColorMask, index);
+ var colorMask = state.Get<RtColorMask>(MethodOffset.RtColorMask, rtColorMaskShared ? 0 : index);
uint componentMask = 0;
@@ -634,7 +662,9 @@ namespace Ryujinx.Graphics.Gpu.Engine
addressesArray[index] = baseAddress + shader.Offset;
}
- GraphicsShader gs = _shaderCache.GetGraphicsShader(addresses);
+ bool viewportTransformEnable = GetViewportTransformEnable(state);
+
+ GraphicsShader gs = _shaderCache.GetGraphicsShader(addresses, !viewportTransformEnable);
_vsUsesInstanceId = gs.Shader[0].Program.Info.UsesInstanceId;
@@ -695,6 +725,14 @@ namespace Ryujinx.Graphics.Gpu.Engine
_context.Renderer.Pipeline.BindProgram(gs.HostProgram);
}
+ private bool GetViewportTransformEnable(GpuState state)
+ {
+ // FIXME: We should read ViewportTransformEnable, but it seems that some games writes 0 there?
+ // return state.Get<Boolean32>(MethodOffset.ViewportTransformEnable) != 0;
+
+ return true;
+ }
+
private static Target GetTarget(SamplerType type)
{
type &= ~(SamplerType.Indexed | SamplerType.Shadow);
diff --git a/Ryujinx.Graphics.Gpu/NvGpuFifo.cs b/Ryujinx.Graphics.Gpu/NvGpuFifo.cs
index 64947bf63..6e02f3915 100644
--- a/Ryujinx.Graphics.Gpu/NvGpuFifo.cs
+++ b/Ryujinx.Graphics.Gpu/NvGpuFifo.cs
@@ -105,6 +105,8 @@ namespace Ryujinx.Graphics.Gpu
{
case NvGpuFifoMeth.WaitForIdle:
{
+ _context.Methods.PerformDeferredDraws();
+
_context.Renderer.FlushPipelines();
break;
diff --git a/Ryujinx.Graphics.Gpu/Shader/ShaderCache.cs b/Ryujinx.Graphics.Gpu/Shader/ShaderCache.cs
index 8e39662d1..6e3a42a23 100644
--- a/Ryujinx.Graphics.Gpu/Shader/ShaderCache.cs
+++ b/Ryujinx.Graphics.Gpu/Shader/ShaderCache.cs
@@ -69,7 +69,7 @@ namespace Ryujinx.Graphics.Gpu.Shader
return cpShader;
}
- public GraphicsShader GetGraphicsShader(ShaderAddresses addresses)
+ public GraphicsShader GetGraphicsShader(ShaderAddresses addresses, bool dividePosXY)
{
bool isCached = _gpPrograms.TryGetValue(addresses, out List<GraphicsShader> list);
@@ -86,19 +86,28 @@ namespace Ryujinx.Graphics.Gpu.Shader
GraphicsShader gpShaders = new GraphicsShader();
+ TranslationFlags flags =
+ TranslationFlags.DebugMode |
+ TranslationFlags.Unspecialized;
+
+ if (dividePosXY)
+ {
+ flags |= TranslationFlags.DividePosXY;
+ }
+
if (addresses.VertexA != 0)
{
- gpShaders.Shader[0] = TranslateGraphicsShader(addresses.Vertex, addresses.VertexA);
+ gpShaders.Shader[0] = TranslateGraphicsShader(flags, addresses.Vertex, addresses.VertexA);
}
else
{
- gpShaders.Shader[0] = TranslateGraphicsShader(addresses.Vertex);
+ gpShaders.Shader[0] = TranslateGraphicsShader(flags, addresses.Vertex);
}
- gpShaders.Shader[1] = TranslateGraphicsShader(addresses.TessControl);
- gpShaders.Shader[2] = TranslateGraphicsShader(addresses.TessEvaluation);
- gpShaders.Shader[3] = TranslateGraphicsShader(addresses.Geometry);
- gpShaders.Shader[4] = TranslateGraphicsShader(addresses.Fragment);
+ gpShaders.Shader[1] = TranslateGraphicsShader(flags, addresses.TessControl);
+ gpShaders.Shader[2] = TranslateGraphicsShader(flags, addresses.TessEvaluation);
+ gpShaders.Shader[3] = TranslateGraphicsShader(flags, addresses.Geometry);
+ gpShaders.Shader[4] = TranslateGraphicsShader(flags, addresses.Fragment);
BackpropQualifiers(gpShaders);
@@ -218,7 +227,7 @@ namespace Ryujinx.Graphics.Gpu.Shader
return new CachedShader(program, codeCached);
}
- private CachedShader TranslateGraphicsShader(ulong gpuVa, ulong gpuVaA = 0)
+ private CachedShader TranslateGraphicsShader(TranslationFlags flags, ulong gpuVa, ulong gpuVaA = 0)
{
if (gpuVa == 0)
{
@@ -227,10 +236,6 @@ namespace Ryujinx.Graphics.Gpu.Shader
ShaderProgram program;
- const TranslationFlags flags =
- TranslationFlags.DebugMode |
- TranslationFlags.Unspecialized;
-
int[] codeCached = null;
if (gpuVaA != 0)
@@ -345,7 +350,9 @@ namespace Ryujinx.Graphics.Gpu.Shader
private ShaderCapabilities GetShaderCapabilities()
{
- return new ShaderCapabilities(_context.Capabilities.StorageBufferOffsetAlignment);
+ return new ShaderCapabilities(
+ _context.Capabilities.MaximumViewportDimensions,
+ _context.Capabilities.StorageBufferOffsetAlignment);
}
}
}
\ No newline at end of file
diff --git a/Ryujinx.Graphics.Gpu/State/GpuState.cs b/Ryujinx.Graphics.Gpu/State/GpuState.cs
index 13f777c91..509f67152 100644
--- a/Ryujinx.Graphics.Gpu/State/GpuState.cs
+++ b/Ryujinx.Graphics.Gpu/State/GpuState.cs
@@ -94,11 +94,17 @@ namespace Ryujinx.Graphics.Gpu.State
_backingMemory[(int)MethodOffset.ViewportExtents + index * 4 + 3] = 0x3F800000;
}
+ // Viewport transform enable.
+ _backingMemory[(int)MethodOffset.ViewportTransformEnable] = 1;
+
// Default front stencil mask.
_backingMemory[0x4e7] = 0xff;
// Default color mask.
- _backingMemory[(int)MethodOffset.RtColorMask] = 0x1111;
+ for (int index = 0; index < Constants.TotalRenderTargets; index++)
+ {
+ _backingMemory[(int)MethodOffset.RtColorMask + index] = 0x1111;
+ }
}
public void RegisterCallback(MethodOffset offset, int count, MethodCallback callback)
diff --git a/Ryujinx.Graphics.Gpu/State/MethodOffset.cs b/Ryujinx.Graphics.Gpu/State/MethodOffset.cs
index a560c257c..93cd6f063 100644
--- a/Ryujinx.Graphics.Gpu/State/MethodOffset.cs
+++ b/Ryujinx.Graphics.Gpu/State/MethodOffset.cs
@@ -29,8 +29,10 @@ namespace Ryujinx.Graphics.Gpu.State
StencilBackMasks = 0x3d5,
InvalidateTextures = 0x3dd,
TextureBarrierTiled = 0x3df,
+ RtColorMaskShared = 0x3e4,
RtDepthStencilState = 0x3f8,
VertexAttribState = 0x458,
+ RtControl = 0x487,
RtDepthStencilSize = 0x48a,
SamplerIndex = 0x48d,
DepthTestEnable = 0x4b3,
@@ -62,6 +64,7 @@ namespace Ryujinx.Graphics.Gpu.State
DepthBiasClamp = 0x61f,
VertexBufferInstanced = 0x620,
FaceState = 0x646,
+ ViewportTransformEnable = 0x64b,
Clear = 0x674,
RtColorMask = 0x680,
ReportState = 0x6c0,
diff --git a/Ryujinx.Graphics.Gpu/State/RtControl.cs b/Ryujinx.Graphics.Gpu/State/RtControl.cs
new file mode 100644
index 000000000..4c6fbc343
--- /dev/null
+++ b/Ryujinx.Graphics.Gpu/State/RtControl.cs
@@ -0,0 +1,17 @@
+namespace Ryujinx.Graphics.Gpu.State
+{
+ struct RtControl
+ {
+ public uint Packed;
+
+ public int UnpackCount()
+ {
+ return (int)(Packed & 0xf);
+ }
+
+ public int UnpackPermutationIndex(int index)
+ {
+ return (int)((Packed >> (4 + index * 3)) & 7);
+ }
+ }
+}
diff --git a/Ryujinx.Graphics.OpenGL/HwCapabilities.cs b/Ryujinx.Graphics.OpenGL/HwCapabilities.cs
index 70112a3a9..671bd5b20 100644
--- a/Ryujinx.Graphics.OpenGL/HwCapabilities.cs
+++ b/Ryujinx.Graphics.OpenGL/HwCapabilities.cs
@@ -7,10 +7,12 @@ namespace Ryujinx.Graphics.OpenGL
{
private static Lazy<bool> _supportsAstcCompression = new Lazy<bool>(() => HasExtension("GL_KHR_texture_compression_astc_ldr"));
+ private static Lazy<int> _maximumViewportDimensions = new Lazy<int>(() => GetLimit(All.MaxViewportDims));
private static Lazy<int> _storageBufferOffsetAlignment = new Lazy<int>(() => GetLimit(All.ShaderStorageBufferOffsetAlignment));
public static bool SupportsAstcCompression => _supportsAstcCompression.Value;
+ public static int MaximumViewportDimensions => _maximumViewportDimensions.Value;
public static int StorageBufferOffsetAlignment => _storageBufferOffsetAlignment.Value;
private static bool HasExtension(string name)
diff --git a/Ryujinx.Graphics.OpenGL/Renderer.cs b/Ryujinx.Graphics.OpenGL/Renderer.cs
index c320d1504..3007fe5cc 100644
--- a/Ryujinx.Graphics.OpenGL/Renderer.cs
+++ b/Ryujinx.Graphics.OpenGL/Renderer.cs
@@ -63,6 +63,7 @@ namespace Ryujinx.Graphics.OpenGL
{
return new Capabilities(
HwCapabilities.SupportsAstcCompression,
+ HwCapabilities.MaximumViewportDimensions,
HwCapabilities.StorageBufferOffsetAlignment);
}
diff --git a/Ryujinx.Graphics.Shader/CodeGen/Glsl/Declarations.cs b/Ryujinx.Graphics.Shader/CodeGen/Glsl/Declarations.cs
index a5c8cc9a9..85a0001b0 100644
--- a/Ryujinx.Graphics.Shader/CodeGen/Glsl/Declarations.cs
+++ b/Ryujinx.Graphics.Shader/CodeGen/Glsl/Declarations.cs
@@ -142,6 +142,16 @@ namespace Ryujinx.Graphics.Shader.CodeGen.Glsl
context.AppendLine();
}
+ if ((info.HelperFunctionsMask & HelperFunctionsMask.MultiplyHighS32) != 0)
+ {
+ AppendHelperFunction(context, "Ryujinx.Graphics.Shader/CodeGen/Glsl/HelperFunctions/MultiplyHighS32.glsl");
+ }
+
+ if ((info.HelperFunctionsMask & HelperFunctionsMask.MultiplyHighU32) != 0)
+ {
+ AppendHelperFunction(context, "Ryujinx.Graphics.Shader/CodeGen/Glsl/HelperFunctions/MultiplyHighU32.glsl");
+ }
+
if ((info.HelperFunctionsMask & HelperFunctionsMask.Shuffle) != 0)
{
AppendHelperFunction(context, "Ryujinx.Graphics.Shader/CodeGen/Glsl/HelperFunctions/Shuffle.glsl");
@@ -170,6 +180,9 @@ namespace Ryujinx.Graphics.Shader.CodeGen.Glsl
public static void DeclareLocals(CodeGenContext context, StructuredProgramInfo info)
{
+ context.AppendLine(GetVarTypeName(VariableType.S32) + " " + DefaultNames.DummyIntName + ";");
+ context.AppendLine(GetVarTypeName(VariableType.U32) + " " + DefaultNames.DummyUintName + ";");
+
foreach (AstOperand decl in info.Locals)
{
string name = context.OperandManager.DeclareLocal(decl);
diff --git a/Ryujinx.Graphics.Shader/CodeGen/Glsl/DefaultNames.cs b/Ryujinx.Graphics.Shader/CodeGen/Glsl/DefaultNames.cs
index 4da38b2de..90853b9f6 100644
--- a/Ryujinx.Graphics.Shader/CodeGen/Glsl/DefaultNames.cs
+++ b/Ryujinx.Graphics.Shader/CodeGen/Glsl/DefaultNames.cs
@@ -22,6 +22,9 @@ namespace Ryujinx.Graphics.Shader.CodeGen.Glsl
public const string LocalMemoryName = "local_mem";
public const string SharedMemoryName = "shared_mem";
+ public const string DummyIntName = "dummyInt";
+ public const string DummyUintName = "dummyUint";
+
public const string UndefinedName = "undef";
}
}
\ No newline at end of file
diff --git a/Ryujinx.Graphics.Shader/CodeGen/Glsl/HelperFunctions/HelperFunctionNames.cs b/Ryujinx.Graphics.Shader/CodeGen/Glsl/HelperFunctions/HelperFunctionNames.cs
index f1540fbfb..21c435475 100644
--- a/Ryujinx.Graphics.Shader/CodeGen/Glsl/HelperFunctions/HelperFunctionNames.cs
+++ b/Ryujinx.Graphics.Shader/CodeGen/Glsl/HelperFunctions/HelperFunctionNames.cs
@@ -2,6 +2,9 @@ namespace Ryujinx.Graphics.Shader.CodeGen.Glsl
{
static class HelperFunctionNames
{
+ public static string MultiplyHighS32 = "Helper_MultiplyHighS32";
+ public static string MultiplyHighU32 = "Helper_MultiplyHighU32";
+
public static string Shuffle = "Helper_Shuffle";
public static string ShuffleDown = "Helper_ShuffleDown";
public static string ShuffleUp = "Helper_ShuffleUp";
diff --git a/Ryujinx.Graphics.Shader/CodeGen/Glsl/HelperFunctions/MultiplyHighS32.glsl b/Ryujinx.Graphics.Shader/CodeGen/Glsl/HelperFunctions/MultiplyHighS32.glsl
new file mode 100644
index 000000000..caad6f569
--- /dev/null
+++ b/Ryujinx.Graphics.Shader/CodeGen/Glsl/HelperFunctions/MultiplyHighS32.glsl
@@ -0,0 +1,7 @@
+int Helper_MultiplyHighS32(int x, int y)
+{
+ int msb;
+ int lsb;
+ imulExtended(x, y, msb, lsb);
+ return msb;
+}
\ No newline at end of file
diff --git a/Ryujinx.Graphics.Shader/CodeGen/Glsl/HelperFunctions/MultiplyHighU32.glsl b/Ryujinx.Graphics.Shader/CodeGen/Glsl/HelperFunctions/MultiplyHighU32.glsl
new file mode 100644
index 000000000..617a925f6
--- /dev/null
+++ b/Ryujinx.Graphics.Shader/CodeGen/Glsl/HelperFunctions/MultiplyHighU32.glsl
@@ -0,0 +1,7 @@
+uint Helper_MultiplyHighU32(uint x, uint y)
+{
+ uint msb;
+ uint lsb;
+ umulExtended(x, y, msb, lsb);
+ return msb;
+}
\ No newline at end of file
diff --git a/Ryujinx.Graphics.Shader/CodeGen/Glsl/Instructions/InstGenHelper.cs b/Ryujinx.Graphics.Shader/CodeGen/Glsl/Instructions/InstGenHelper.cs
index f013ee10c..2b4ae7f19 100644
--- a/Ryujinx.Graphics.Shader/CodeGen/Glsl/Instructions/InstGenHelper.cs
+++ b/Ryujinx.Graphics.Shader/CodeGen/Glsl/Instructions/InstGenHelper.cs
@@ -93,6 +93,8 @@ namespace Ryujinx.Graphics.Shader.CodeGen.Glsl.Instructions
Add(Instruction.Minimum, InstType.CallBinary, "min");
Add(Instruction.MinimumU32, InstType.CallBinary, "min");
Add(Instruction.Multiply, InstType.OpBinaryCom, "*", 1);
+ Add(Instruction.MultiplyHighS32, InstType.CallBinary, HelperFunctionNames.MultiplyHighS32);
+ Add(Instruction.MultiplyHighU32, InstType.CallBinary, HelperFunctionNames.MultiplyHighU32);
Add(Instruction.Negate, InstType.OpUnary, "-", 0);
Add(Instruction.ReciprocalSquareRoot, InstType.CallUnary, "inversesqrt");
Add(Instruction.Return, InstType.OpNullary, "return");
diff --git a/Ryujinx.Graphics.Shader/CodeGen/Glsl/Instructions/InstGenMemory.cs b/Ryujinx.Graphics.Shader/CodeGen/Glsl/Instructions/InstGenMemory.cs
index 5c2ea85e6..ffed4c71c 100644
--- a/Ryujinx.Graphics.Shader/CodeGen/Glsl/Instructions/InstGenMemory.cs
+++ b/Ryujinx.Graphics.Shader/CodeGen/Glsl/Instructions/InstGenMemory.cs
@@ -1,6 +1,5 @@
using Ryujinx.Graphics.Shader.IntermediateRepresentation;
using Ryujinx.Graphics.Shader.StructuredIr;
-using Ryujinx.Graphics.Shader.Translation.Optimizations;
using System;
using static Ryujinx.Graphics.Shader.CodeGen.Glsl.Instructions.InstGenHelper;
diff --git a/Ryujinx.Graphics.Shader/Decoders/OpCodeTable.cs b/Ryujinx.Graphics.Shader/Decoders/OpCodeTable.cs
index 599c674f3..0837e1858 100644
--- a/Ryujinx.Graphics.Shader/Decoders/OpCodeTable.cs
+++ b/Ryujinx.Graphics.Shader/Decoders/OpCodeTable.cs
@@ -57,6 +57,7 @@ namespace Ryujinx.Graphics.Shader.Decoders
Set("0101110001011x", InstEmit.Fadd, typeof(OpCodeFArithReg));
Set("010010011xxxxx", InstEmit.Ffma, typeof(OpCodeFArithCbuf));
Set("0011001x1xxxxx", InstEmit.Ffma, typeof(OpCodeFArithImm));
+ Set("000011xxxxxxxx", InstEmit.Ffma32i, typeof(OpCodeFArithImm32));
Set("010100011xxxxx", InstEmit.Ffma, typeof(OpCodeFArithRegCbuf));
Set("010110011xxxxx", InstEmit.Ffma, typeof(OpCodeFArithReg));
Set("0100110000110x", InstEmit.Flo, typeof(OpCodeAluCbuf));
@@ -102,12 +103,16 @@ namespace Ryujinx.Graphics.Shader.Decoders
Set("0011100x11100x", InstEmit.I2I, typeof(OpCodeAluImm));
Set("0101110011100x", InstEmit.I2I, typeof(OpCodeAluReg));
Set("0100110000010x", InstEmit.Iadd, typeof(OpCodeAluCbuf));
- Set("0011100000010x", InstEmit.Iadd, typeof(OpCodeAluImm));
+ Set("0011100x00010x", InstEmit.Iadd, typeof(OpCodeAluImm));
Set("0001110x0xxxxx", InstEmit.Iadd, typeof(OpCodeAluImm32));
Set("0101110000010x", InstEmit.Iadd, typeof(OpCodeAluReg));
Set("010011001100xx", InstEmit.Iadd3, typeof(OpCodeAluCbuf));
- Set("001110001100xx", InstEmit.Iadd3, typeof(OpCodeAluImm));
+ Set("0011100x1100xx", InstEmit.Iadd3, typeof(OpCodeAluImm));
Set("010111001100xx", InstEmit.Iadd3, typeof(OpCodeAluReg));
+ Set("010010100xxxxx", InstEmit.Imad, typeof(OpCodeAluCbuf));
+ Set("0011010x0xxxxx", InstEmit.Imad, typeof(OpCodeAluImm));
+ Set("010110100xxxxx", InstEmit.Imad, typeof(OpCodeAluReg));
+ Set("010100100xxxxx", InstEmit.Imad, typeof(OpCodeAluRegCbuf));
Set("0100110000100x", InstEmit.Imnmx, typeof(OpCodeAluCbuf));
Set("0011100x00100x", InstEmit.Imnmx, typeof(OpCodeAluImm));
Set("0101110000100x", InstEmit.Imnmx, typeof(OpCodeAluReg));
diff --git a/Ryujinx.Graphics.Shader/Instructions/InstEmitAlu.cs b/Ryujinx.Graphics.Shader/Instructions/InstEmitAlu.cs
index 1d3a1101c..2a8f00ccb 100644
--- a/Ryujinx.Graphics.Shader/Instructions/InstEmitAlu.cs
+++ b/Ryujinx.Graphics.Shader/Instructions/InstEmitAlu.cs
@@ -200,6 +200,50 @@ namespace Ryujinx.Graphics.Shader.Instructions
// TODO: CC, X, corner cases
}
+ public static void Imad(EmitterContext context)
+ {
+ OpCodeAlu op = (OpCodeAlu)context.CurrOp;
+
+ bool signedA = context.CurrOp.RawOpCode.Extract(48);
+ bool signedB = context.CurrOp.RawOpCode.Extract(53);
+ bool high = context.CurrOp.RawOpCode.Extract(54);
+
+ Operand srcA = GetSrcA(context);
+ Operand srcB = GetSrcB(context);
+ Operand srcC = GetSrcC(context);
+
+ Operand res;
+
+ if (high)
+ {
+ if (signedA && signedB)
+ {
+ res = context.MultiplyHighS32(srcA, srcB);
+ }
+ else
+ {
+ res = context.MultiplyHighU32(srcA, srcB);
+
+ if (signedA)
+ {
+ res = context.IAdd(res, context.IMultiply(srcB, context.ShiftRightS32(srcA, Const(31))));
+ }
+ else if (signedB)
+ {
+ res = context.IAdd(res, context.IMultiply(srcA, context.ShiftRightS32(srcB, Const(31))));
+ }
+ }
+ }
+ else
+ {
+ res = context.IMultiply(srcA, srcB);
+ }
+
+ res = context.IAdd(res, srcC);
+
+ context.Copy(GetDest(context), res);
+ }
+
public static void Imnmx(EmitterContext context)
{
OpCodeAlu op = (OpCodeAlu)context.CurrOp;
diff --git a/Ryujinx.Graphics.Shader/Instructions/InstEmitFArith.cs b/Ryujinx.Graphics.Shader/Instructions/InstEmitFArith.cs
index 3b8d7305b..63d1efcbc 100644
--- a/Ryujinx.Graphics.Shader/Instructions/InstEmitFArith.cs
+++ b/Ryujinx.Graphics.Shader/Instructions/InstEmitFArith.cs
@@ -59,6 +59,26 @@ namespace Ryujinx.Graphics.Shader.Instructions
SetFPZnFlags(context, dest, op.SetCondCode);
}
+ public static void Ffma32i(EmitterContext context)
+ {
+ IOpCodeFArith op = (IOpCodeFArith)context.CurrOp;
+
+ bool saturate = op.RawOpCode.Extract(55);
+ bool negateA = op.RawOpCode.Extract(56);
+ bool negateC = op.RawOpCode.Extract(57);
+
+ Operand srcA = context.FPNegate(GetSrcA(context), negateA);
+ Operand srcC = context.FPNegate(GetDest(context), negateC);
+
+ Operand srcB = GetSrcB(context);
+
+ Operand dest = GetDest(context);
+
+ context.Copy(dest, context.FPSaturate(context.FPFusedMultiplyAdd(srcA, srcB, srcC), saturate));
+
+ SetFPZnFlags(context, dest, op.SetCondCode);
+ }
+
public static void Fmnmx(EmitterContext context)
{
IOpCodeFArith op = (IOpCodeFArith)context.CurrOp;
diff --git a/Ryujinx.Graphics.Shader/IntermediateRepresentation/Instruction.cs b/Ryujinx.Graphics.Shader/IntermediateRepresentation/Instruction.cs
index 6acaa490c..5f0407c28 100644
--- a/Ryujinx.Graphics.Shader/IntermediateRepresentation/Instruction.cs
+++ b/Ryujinx.Graphics.Shader/IntermediateRepresentation/Instruction.cs
@@ -84,6 +84,8 @@ namespace Ryujinx.Graphics.Shader.IntermediateRepresentation
Minimum,
MinimumU32,
Multiply,
+ MultiplyHighS32,
+ MultiplyHighU32,
Negate,
PackDouble2x32,
PackHalf2x16,
diff --git a/Ryujinx.Graphics.Shader/Ryujinx.Graphics.Shader.csproj b/Ryujinx.Graphics.Shader/Ryujinx.Graphics.Shader.csproj
index e10d1edaf..8715dad31 100644
--- a/Ryujinx.Graphics.Shader/Ryujinx.Graphics.Shader.csproj
+++ b/Ryujinx.Graphics.Shader/Ryujinx.Graphics.Shader.csproj
@@ -1,6 +1,8 @@
<Project Sdk="Microsoft.NET.Sdk">
<ItemGroup>
+ <EmbeddedResource Include="CodeGen\Glsl\HelperFunctions\MultiplyHighS32.glsl" />
+ <EmbeddedResource Include="CodeGen\Glsl\HelperFunctions\MultiplyHighU32.glsl" />
<EmbeddedResource Include="CodeGen\Glsl\HelperFunctions\Shuffle.glsl" />
<EmbeddedResource Include="CodeGen\Glsl\HelperFunctions\ShuffleDown.glsl" />
<EmbeddedResource Include="CodeGen\Glsl\HelperFunctions\ShuffleUp.glsl" />
diff --git a/Ryujinx.Graphics.Shader/ShaderCapabilities.cs b/Ryujinx.Graphics.Shader/ShaderCapabilities.cs
index 939c7c1de..b5b459a8d 100644
--- a/Ryujinx.Graphics.Shader/ShaderCapabilities.cs
+++ b/Ryujinx.Graphics.Shader/ShaderCapabilities.cs
@@ -2,14 +2,18 @@ namespace Ryujinx.Graphics.Shader
{
public struct ShaderCapabilities
{
- private static readonly ShaderCapabilities _default = new ShaderCapabilities(16);
+ private static readonly ShaderCapabilities _default = new ShaderCapabilities(32768, 16);
public static ShaderCapabilities Default => _default;
+ public int MaximumViewportDimensions { get; }
public int StorageBufferOffsetAlignment { get; }
- public ShaderCapabilities(int storageBufferOffsetAlignment)
+ public ShaderCapabilities(
+ int maximumViewportDimensions,
+ int storageBufferOffsetAlignment)
{
+ MaximumViewportDimensions = maximumViewportDimensions;
StorageBufferOffsetAlignment = storageBufferOffsetAlignment;
}
}
diff --git a/Ryujinx.Graphics.Shader/StructuredIr/HelperFunctionsMask.cs b/Ryujinx.Graphics.Shader/StructuredIr/HelperFunctionsMask.cs
index e2eee78d9..53367fce1 100644
--- a/Ryujinx.Graphics.Shader/StructuredIr/HelperFunctionsMask.cs
+++ b/Ryujinx.Graphics.Shader/StructuredIr/HelperFunctionsMask.cs
@@ -5,10 +5,12 @@ namespace Ryujinx.Graphics.Shader.StructuredIr
[Flags]
enum HelperFunctionsMask
{
- Shuffle = 1 << 0,
- ShuffleDown = 1 << 1,
- ShuffleUp = 1 << 2,
- ShuffleXor = 1 << 3,
- SwizzleAdd = 1 << 4
+ MultiplyHighS32 = 1 << 0,
+ MultiplyHighU32 = 1 << 1,
+ Shuffle = 1 << 2,
+ ShuffleDown = 1 << 3,
+ ShuffleUp = 1 << 4,
+ ShuffleXor = 1 << 5,
+ SwizzleAdd = 1 << 6
}
}
\ No newline at end of file
diff --git a/Ryujinx.Graphics.Shader/StructuredIr/InstructionInfo.cs b/Ryujinx.Graphics.Shader/StructuredIr/InstructionInfo.cs
index d1874f50f..9614b6598 100644
--- a/Ryujinx.Graphics.Shader/StructuredIr/InstructionInfo.cs
+++ b/Ryujinx.Graphics.Shader/StructuredIr/InstructionInfo.cs
@@ -102,6 +102,8 @@ namespace Ryujinx.Graphics.Shader.StructuredIr
Add(Instruction.Minimum, VariableType.Scalar, VariableType.Scalar, VariableType.Scalar);
Add(Instruction.MinimumU32, VariableType.U32, VariableType.U32, VariableType.U32);
Add(Instruction.Multiply, VariableType.Scalar, VariableType.Scalar, VariableType.Scalar);
+ Add(Instruction.MultiplyHighS32, VariableType.S32, VariableType.S32, VariableType.S32);
+ Add(Instruction.MultiplyHighU32, VariableType.U32, VariableType.U32, VariableType.U32);
Add(Instruction.Negate, VariableType.Scalar, VariableType.Scalar);
Add(Instruction.PackHalf2x16, VariableType.U32, VariableType.F32, VariableType.F32);
Add(Instruction.ReciprocalSquareRoot, VariableType.Scalar, VariableType.Scalar);
diff --git a/Ryujinx.Graphics.Shader/StructuredIr/StructuredProgram.cs b/Ryujinx.Graphics.Shader/StructuredIr/StructuredProgram.cs
index a85fbae3d..504dc3867 100644
--- a/Ryujinx.Graphics.Shader/StructuredIr/StructuredProgram.cs
+++ b/Ryujinx.Graphics.Shader/StructuredIr/StructuredProgram.cs
@@ -171,6 +171,12 @@ namespace Ryujinx.Graphics.Shader.StructuredIr
// decide which helper functions are needed on the final generated code.
switch (operation.Inst)
{
+ case Instruction.MultiplyHighS32:
+ context.Info.HelperFunctionsMask |= HelperFunctionsMask.MultiplyHighS32;
+ break;
+ case Instruction.MultiplyHighU32:
+ context.Info.HelperFunctionsMask |= HelperFunctionsMask.MultiplyHighU32;
+ break;
case Instruction.Shuffle:
context.Info.HelperFunctionsMask |= HelperFunctionsMask.Shuffle;
break;
diff --git a/Ryujinx.Graphics.Shader/Translation/EmitterContext.cs b/Ryujinx.Graphics.Shader/Translation/EmitterContext.cs
index 3995d4306..7ba7b697b 100644
--- a/Ryujinx.Graphics.Shader/Translation/EmitterContext.cs
+++ b/Ryujinx.Graphics.Shader/Translation/EmitterContext.cs
@@ -11,18 +11,25 @@ namespace Ryujinx.Graphics.Shader.Translation
public Block CurrBlock { get; set; }
public OpCode CurrOp { get; set; }
- private ShaderStage _stage;
-
- private ShaderHeader _header;
+ private ShaderStage _stage;
+ private ShaderHeader _header;
+ private ShaderCapabilities _capabilities;
+ private TranslationFlags _flags;
private List<Operation> _operations;
private Dictionary<ulong, Operand> _labels;
- public EmitterContext(ShaderStage stage, ShaderHeader header)
+ public EmitterContext(
+ ShaderStage stage,
+ ShaderHeader header,
+ ShaderCapabilities capabilities,
+ TranslationFlags flags)
{
- _stage = stage;
- _header = header;
+ _stage = stage;
+ _header = header;
+ _capabilities = capabilities;
+ _flags = flags;
_operations = new List<Operation>();
@@ -62,7 +69,18 @@ namespace Ryujinx.Graphics.Shader.Translation
public void PrepareForReturn()
{
- if (_stage == ShaderStage.Fragment)
+ if (_stage == ShaderStage.Vertex)
+ {
+ if ((_flags & TranslationFlags.DividePosXY) != 0)
+ {
+ Operand posX = Attribute(AttributeConsts.PositionX);
+ Operand posY = Attribute(AttributeConsts.PositionY);
+
+ this.Copy(posX, this.FPDivide(posX, ConstF(_capabilities.MaximumViewportDimensions / 2)));
+ this.Copy(posY, this.FPDivide(posY, ConstF(_capabilities.MaximumViewportDimensions / 2)));
+ }
+ }
+ else if (_stage == ShaderStage.Fragment)
{
if (_header.OmapDepth)
{
diff --git a/Ryujinx.Graphics.Shader/Translation/EmitterContextInsts.cs b/Ryujinx.Graphics.Shader/Translation/EmitterContextInsts.cs
index d884cfdb3..e39d8c645 100644
--- a/Ryujinx.Graphics.Shader/Translation/EmitterContextInsts.cs
+++ b/Ryujinx.Graphics.Shader/Translation/EmitterContextInsts.cs
@@ -476,6 +476,16 @@ namespace Ryujinx.Graphics.Shader.Translation
return context.Add(Instruction.LoadShared, Local(), a);
}
+ public static Operand MultiplyHighS32(this EmitterContext context, Operand a, Operand b)
+ {
+ return context.Add(Instruction.MultiplyHighS32, Local(), a, b);
+ }
+
+ public static Operand MultiplyHighU32(this EmitterContext context, Operand a, Operand b)
+ {
+ return context.Add(Instruction.MultiplyHighU32, Local(), a, b);
+ }
+
public static Operand PackHalf2x16(this EmitterContext context, Operand a, Operand b)
{
return context.Add(Instruction.PackHalf2x16, Local(), a, b);
diff --git a/Ryujinx.Graphics.Shader/Translation/TranslationFlags.cs b/Ryujinx.Graphics.Shader/Translation/TranslationFlags.cs
index 99b6107a9..8faa43836 100644
--- a/Ryujinx.Graphics.Shader/Translation/TranslationFlags.cs
+++ b/Ryujinx.Graphics.Shader/Translation/TranslationFlags.cs
@@ -6,6 +6,7 @@ namespace Ryujinx.Graphics.Shader.Translation
Compute = 1 << 0,
DebugMode = 1 << 1,
- Unspecialized = 1 << 2
+ Unspecialized = 1 << 2,
+ DividePosXY = 1 << 3
}
}
\ No newline at end of file
diff --git a/Ryujinx.Graphics.Shader/Translation/Translator.cs b/Ryujinx.Graphics.Shader/Translation/Translator.cs
index b129be939..69e63ae13 100644
--- a/Ryujinx.Graphics.Shader/Translation/Translator.cs
+++ b/Ryujinx.Graphics.Shader/Translation/Translator.cs
@@ -49,15 +49,9 @@ namespace Ryujinx.Graphics.Shader.Translation
public static ShaderProgram Translate(Span<byte> code, ShaderCapabilities capabilities, TranslationFlags flags)
{
- bool compute = (flags & TranslationFlags.Compute) != 0;
- bool debugMode = (flags & TranslationFlags.DebugMode) != 0;
+ bool compute = (flags & TranslationFlags.Compute) != 0;
- Operation[] ops = DecodeShader(
- code,
- compute,
- debugMode,
- out ShaderHeader header,
- out int size);
+ Operation[] ops = DecodeShader(code, capabilities, flags, out ShaderHeader header, out int size);
ShaderStage stage;
@@ -94,8 +88,8 @@ namespace Ryujinx.Graphics.Shader.Translation
{
bool debugMode = (flags & TranslationFlags.DebugMode) != 0;
- Operation[] vpAOps = DecodeShader(vpACode, compute: false, debugMode, out _, out _);
- Operation[] vpBOps = DecodeShader(vpBCode, compute: false, debugMode, out ShaderHeader header, out int sizeB);
+ Operation[] vpAOps = DecodeShader(vpACode, capabilities, flags, out _, out _);
+ Operation[] vpBOps = DecodeShader(vpBCode, capabilities, flags, out ShaderHeader header, out int sizeB);
ShaderConfig config = new ShaderConfig(
header.Stage,
@@ -142,23 +136,23 @@ namespace Ryujinx.Graphics.Shader.Translation
}
private static Operation[] DecodeShader(
- Span<byte> code,
- bool compute,
- bool debugMode,
- out ShaderHeader header,
- out int size)
+ Span<byte> code,
+ ShaderCapabilities capabilities,
+ TranslationFlags flags,
+ out ShaderHeader header,
+ out int size)
{
Block[] cfg;
EmitterContext context;
- if (compute)
+ if ((flags & TranslationFlags.Compute) != 0)
{
header = null;
cfg = Decoder.Decode(code, 0);
- context = new EmitterContext(ShaderStage.Compute, header);
+ context = new EmitterContext(ShaderStage.Compute, header, capabilities, flags);
}
else
{
@@ -166,7 +160,7 @@ namespace Ryujinx.Graphics.Shader.Translation
cfg = Decoder.Decode(code, HeaderSize);
- context = new EmitterContext(header.Stage, header);
+ context = new EmitterContext(header.Stage, header, capabilities, flags);
}
if (cfg == null)
@@ -197,7 +191,7 @@ namespace Ryujinx.Graphics.Shader.Translation
{
OpCode op = block.OpCodes[opIndex];
- if (debugMode)
+ if ((flags & TranslationFlags.DebugMode) != 0)
{
string instName;
@@ -274,7 +268,7 @@ namespace Ryujinx.Graphics.Shader.Translation
}
}
- size = (int)maxEndAddress + (compute ? 0 : HeaderSize);
+ size = (int)maxEndAddress + (((flags & TranslationFlags.Compute) != 0) ? 0 : HeaderSize);
return context.GetOperations();
}