Support texture rectangle targets (non-normalized coords)

14 files changed, 322 insertions, 268 deletions

diff --git a/Ryujinx.Graphics.Shader/CodeGen/Glsl/Declarations.cs b/Ryujinx.Graphics.Shader/CodeGen/Glsl/Declarations.cs
index b96aa1ae..bad5c00c 100644
--- a/Ryujinx.Graphics.Shader/CodeGen/Glsl/Declarations.cs
+++ b/Ryujinx.Graphics.Shader/CodeGen/Glsl/Declarations.cs
@@ -35,23 +35,11 @@ namespace Ryujinx.Graphics.Shader.CodeGen.Glsl
 
             if (context.Config.Stage == ShaderStage.Geometry)
             {
-                string inPrimitive = "points";
-
-                if ((context.Config.Flags & TranslationFlags.Unspecialized) != 0)
-                {
-                    inPrimitive = DefineNames.InputTopologyName;
-                }
+                string inPrimitive = ((InputTopology)context.Config.QueryInfo(QueryInfoName.PrimitiveTopology)).ToGlslString();
 
                 context.AppendLine($"layout ({inPrimitive}) in;");
 
-                string outPrimitive = "triangle_strip";
-
-                switch (context.Config.OutputTopology)
-                {
-                    case OutputTopology.LineStrip:     outPrimitive = "line_strip";     break;
-                    case OutputTopology.PointList:     outPrimitive = "points";         break;
-                    case OutputTopology.TriangleStrip: outPrimitive = "triangle_strip"; break;
-                }
+                string outPrimitive = context.Config.OutputTopology.ToGlslString();
 
                 int maxOutputVertices = context.Config.MaxOutputVertices;
 
@@ -75,16 +63,7 @@ namespace Ryujinx.Graphics.Shader.CodeGen.Glsl
 
             if (context.Config.Stage == ShaderStage.Compute)
             {
-                string size;
-
-                if ((context.Config.Flags & TranslationFlags.Unspecialized) != 0)
-                {
-                    size = DefineNames.SharedMemorySize;
-                }
-                else
-                {
-                    size = NumberFormatter.FormatInt(context.Config.Capabilities.MaximumComputeSharedMemorySize / 4);
-                }
+                string size = NumberFormatter.FormatInt(BitUtils.DivRoundUp(context.Config.QueryInfo(QueryInfoName.ComputeSharedMemorySize), 4));
 
                 context.AppendLine($"shared uint {DefaultNames.SharedMemoryName}[{size}];");
                 context.AppendLine();
@@ -136,19 +115,12 @@ namespace Ryujinx.Graphics.Shader.CodeGen.Glsl
             }
             else
             {
-                string localSizeX = "1";
-                string localSizeY = "1";
-                string localSizeZ = "1";
-
-                if ((context.Config.Flags & TranslationFlags.Unspecialized) != 0)
-                {
-                    localSizeX = DefineNames.LocalSizeX;
-                    localSizeY = DefineNames.LocalSizeY;
-                    localSizeZ = DefineNames.LocalSizeZ;
-                }
+                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));
 
                 context.AppendLine(
-                    $"layout (" +
+                    "layout (" +
                     $"local_size_x = {localSizeX}, " +
                     $"local_size_y = {localSizeY}, " +
                     $"local_size_z = {localSizeZ}) in;");
diff --git a/Ryujinx.Graphics.Shader/DefineNames.cs b/Ryujinx.Graphics.Shader/DefineNames.cs
index 67e8e1ee..b0430499 100644
--- a/Ryujinx.Graphics.Shader/DefineNames.cs
+++ b/Ryujinx.Graphics.Shader/DefineNames.cs
@@ -2,14 +2,6 @@ namespace Ryujinx.Graphics.Shader
 {
     public static class DefineNames
     {
-        public const string InputTopologyName = "S_INPUT_TOPOLOGY";
-
         public const string OutQualifierPrefixName = "S_OUT_QUALIFIER";
-
-        public const string SharedMemorySize = "S_SHARED_MEMORY_SIZE";
-
-        public const string LocalSizeX = "S_LOCAL_SIZE_X";
-        public const string LocalSizeY = "S_LOCAL_SIZE_Y";
-        public const string LocalSizeZ = "S_LOCAL_SIZE_Z";
     }
 }
\ No newline at end of file
diff --git a/Ryujinx.Graphics.Shader/InputTopology.cs b/Ryujinx.Graphics.Shader/InputTopology.cs
new file mode 100644
index 00000000..3b0dda45
--- /dev/null
+++ b/Ryujinx.Graphics.Shader/InputTopology.cs
@@ -0,0 +1,28 @@
+namespace Ryujinx.Graphics.Shader
+{
+    public enum InputTopology
+    {
+        Points,
+        Lines,
+        LinesAdjacency,
+        Triangles,
+        TrianglesAdjacency
+    }
+
+    static class InputTopologyExtensions
+    {
+        public static string ToGlslString(this InputTopology topology)
+        {
+            switch (topology)
+            {
+                case InputTopology.Points:             return "points";
+                case InputTopology.Lines:              return "lines";
+                case InputTopology.LinesAdjacency:     return "lines_adjacency";
+                case InputTopology.Triangles:          return "triangles";
+                case InputTopology.TrianglesAdjacency: return "triangles_adjacency";
+            }
+
+            return "points";
+        }
+    }
+}
\ No newline at end of file
diff --git a/Ryujinx.Graphics.Shader/OutputTopology.cs b/Ryujinx.Graphics.Shader/OutputTopology.cs
index e8336aa3..6f977bec 100644
--- a/Ryujinx.Graphics.Shader/OutputTopology.cs
+++ b/Ryujinx.Graphics.Shader/OutputTopology.cs
@@ -6,4 +6,19 @@ namespace Ryujinx.Graphics.Shader
         LineStrip     = 6,
         TriangleStrip = 7
     }
+
+    static class OutputTopologyExtensions
+    {
+        public static string ToGlslString(this OutputTopology topology)
+        {
+            switch (topology)
+            {
+                case OutputTopology.LineStrip:     return "line_strip";
+                case OutputTopology.PointList:     return "points";
+                case OutputTopology.TriangleStrip: return "triangle_strip";
+            }
+
+            return "points";
+        }
+    }
 }
\ No newline at end of file
diff --git a/Ryujinx.Graphics.Shader/QueryInfoCallback.cs b/Ryujinx.Graphics.Shader/QueryInfoCallback.cs
new file mode 100644
index 00000000..28261a77
--- /dev/null
+++ b/Ryujinx.Graphics.Shader/QueryInfoCallback.cs
@@ -0,0 +1,4 @@
+namespace Ryujinx.Graphics.Shader
+{
+    public delegate int QueryInfoCallback(QueryInfoName info, int index);
+}
\ No newline at end of file
diff --git a/Ryujinx.Graphics.Shader/QueryInfoName.cs b/Ryujinx.Graphics.Shader/QueryInfoName.cs
new file mode 100644
index 00000000..e976dcdb
--- /dev/null
+++ b/Ryujinx.Graphics.Shader/QueryInfoName.cs
@@ -0,0 +1,17 @@
+namespace Ryujinx.Graphics.Shader
+{
+    public enum QueryInfoName
+    {
+        ComputeLocalSizeX,
+        ComputeLocalSizeY,
+        ComputeLocalSizeZ,
+        ComputeSharedMemorySize,
+        IsTextureBuffer,
+        IsTextureRectangle,
+        MaximumViewportDimensions,
+        PrimitiveTopology,
+        StorageBufferOffsetAlignment,
+        SupportsNonConstantTextureOffset,
+        ViewportTransformEnable
+    }
+}
\ No newline at end of file
diff --git a/Ryujinx.Graphics.Shader/ShaderCapabilities.cs b/Ryujinx.Graphics.Shader/ShaderCapabilities.cs
deleted file mode 100644
index 809481b5..00000000
--- a/Ryujinx.Graphics.Shader/ShaderCapabilities.cs
+++ /dev/null
@@ -1,27 +0,0 @@
-namespace Ryujinx.Graphics.Shader
-{
-    public struct ShaderCapabilities
-    {
-        // Initialize with default values for Maxwell.
-        private static readonly ShaderCapabilities _default = new ShaderCapabilities(0x8000, 0xc000, 16, true);
-
-        public static ShaderCapabilities Default => _default;
-
-        public int  MaximumViewportDimensions        { get; }
-        public int  MaximumComputeSharedMemorySize   { get; }
-        public int  StorageBufferOffsetAlignment     { get; }
-        public bool SupportsNonConstantTextureOffset { get; }
-
-        public ShaderCapabilities(
-            int  maximumViewportDimensions,
-            int  maximumComputeSharedMemorySize,
-            int  storageBufferOffsetAlignment,
-            bool supportsNonConstantTextureOffset)
-        {
-            MaximumViewportDimensions        = maximumViewportDimensions;
-            MaximumComputeSharedMemorySize   = maximumComputeSharedMemorySize;
-            StorageBufferOffsetAlignment     = storageBufferOffsetAlignment;
-            SupportsNonConstantTextureOffset = supportsNonConstantTextureOffset;
-        }
-    }
-}
\ No newline at end of file
diff --git a/Ryujinx.Graphics.Shader/ShaderConfig.cs b/Ryujinx.Graphics.Shader/ShaderConfig.cs
index 3088cfbb..6b3640df 100644
--- a/Ryujinx.Graphics.Shader/ShaderConfig.cs
+++ b/Ryujinx.Graphics.Shader/ShaderConfig.cs
@@ -1,4 +1,5 @@
 using Ryujinx.Graphics.Shader.Translation;
+using System;
 
 namespace Ryujinx.Graphics.Shader
 {
@@ -6,26 +7,100 @@ namespace Ryujinx.Graphics.Shader
     {
         public ShaderStage Stage { get; }
 
-        public ShaderCapabilities Capabilities { get; }
+        public OutputTopology OutputTopology { get; }
+
+        public int MaxOutputVertices { get; }
+
+        public OutputMapTarget[] OmapTargets    { get; }
+        public bool              OmapSampleMask { get; }
+        public bool              OmapDepth      { get; }
 
         public TranslationFlags Flags { get; }
 
-        public int MaxOutputVertices { get; }
+        private QueryInfoCallback _queryInfoCallback;
 
-        public OutputTopology OutputTopology { get; }
+        public ShaderConfig(TranslationFlags flags, QueryInfoCallback queryInfoCallback)
+        {
+            Stage              = ShaderStage.Compute;
+            OutputTopology     = OutputTopology.PointList;
+            MaxOutputVertices  = 0;
+            OmapTargets        = null;
+            OmapSampleMask     = false;
+            OmapDepth          = false;
+            Flags              = flags;
+            _queryInfoCallback = queryInfoCallback;
+        }
+
+        public ShaderConfig(ShaderHeader header, TranslationFlags flags, QueryInfoCallback queryInfoCallback)
+        {
+            Stage              = header.Stage;
+            OutputTopology     = header.OutputTopology;
+            MaxOutputVertices  = header.MaxOutputVertexCount;
+            OmapTargets        = header.OmapTargets;
+            OmapSampleMask     = header.OmapSampleMask;
+            OmapDepth          = header.OmapDepth;
+            Flags              = flags;
+            _queryInfoCallback = queryInfoCallback;
+        }
+
+        public int GetDepthRegister()
+        {
+            int count = 0;
+
+            for (int index = 0; index < OmapTargets.Length; index++)
+            {
+                for (int component = 0; component < 4; component++)
+                {
+                    if (OmapTargets[index].ComponentEnabled(component))
+                    {
+                        count++;
+                    }
+                }
+            }
+
+            // The depth register is always two registers after the last color output.
+            return count + 1;
+        }
 
-        public ShaderConfig(
-            ShaderStage        stage,
-            ShaderCapabilities capabilities,
-            TranslationFlags   flags,
-            int                maxOutputVertices,
-            OutputTopology     outputTopology)
+        public bool QueryInfoBool(QueryInfoName info, int index = 0)
         {
-            Stage             = stage;
-            Capabilities      = capabilities;
-            Flags             = flags;
-            MaxOutputVertices = maxOutputVertices;
-            OutputTopology    = outputTopology;
+            return Convert.ToBoolean(QueryInfo(info, index));
+        }
+
+        public int QueryInfo(QueryInfoName info, int index = 0)
+        {
+            if (_queryInfoCallback != null)
+            {
+                return _queryInfoCallback(info, index);
+            }
+            else
+            {
+                switch (info)
+                {
+                    case QueryInfoName.ComputeLocalSizeX:
+                    case QueryInfoName.ComputeLocalSizeY:
+                    case QueryInfoName.ComputeLocalSizeZ:
+                        return 1;
+                    case QueryInfoName.ComputeSharedMemorySize:
+                        return 0xc000;
+                    case QueryInfoName.IsTextureBuffer:
+                        return Convert.ToInt32(false);
+                    case QueryInfoName.IsTextureRectangle:
+                        return Convert.ToInt32(false);
+                    case QueryInfoName.MaximumViewportDimensions:
+                        return 0x8000;
+                    case QueryInfoName.PrimitiveTopology:
+                        return (int)InputTopology.Points;
+                    case QueryInfoName.StorageBufferOffsetAlignment:
+                        return 16;
+                    case QueryInfoName.SupportsNonConstantTextureOffset:
+                        return Convert.ToInt32(true);
+                    case QueryInfoName.ViewportTransformEnable:
+                        return Convert.ToInt32(true);
+                }
+            }
+
+            return 0;
         }
     }
 }
\ No newline at end of file
diff --git a/Ryujinx.Graphics.Shader/ShaderHeader.cs b/Ryujinx.Graphics.Shader/ShaderHeader.cs
index 94c57435..a8d01086 100644
--- a/Ryujinx.Graphics.Shader/ShaderHeader.cs
+++ b/Ryujinx.Graphics.Shader/ShaderHeader.cs
@@ -76,28 +76,6 @@ namespace Ryujinx.Graphics.Shader
         public bool              OmapSampleMask { get; }
         public bool              OmapDepth      { get; }
 
-        public int DepthRegister
-        {
-            get
-            {
-                int count = 0;
-
-                for (int index = 0; index < OmapTargets.Length; index++)
-                {
-                    for (int component = 0; component < 4; component++)
-                    {
-                        if (OmapTargets[index].ComponentEnabled(component))
-                        {
-                            count++;
-                        }
-                    }
-                }
-
-                // Depth register is always two registers after the last color output.
-                return count + 1;
-            }
-        }
-
         public ShaderHeader(Span<byte> code)
         {
             Span<int> header = MemoryMarshal.Cast<byte, int>(code);
diff --git a/Ryujinx.Graphics.Shader/Translation/EmitterContext.cs b/Ryujinx.Graphics.Shader/Translation/EmitterContext.cs
index 7ba7b697..9620145a 100644
--- a/Ryujinx.Graphics.Shader/Translation/EmitterContext.cs
+++ b/Ryujinx.Graphics.Shader/Translation/EmitterContext.cs
@@ -11,25 +11,15 @@ namespace Ryujinx.Graphics.Shader.Translation
         public Block  CurrBlock { get; set; }
         public OpCode CurrOp    { get; set; }
 
-        private ShaderStage        _stage;
-        private ShaderHeader       _header;
-        private ShaderCapabilities _capabilities;
-        private TranslationFlags   _flags;
+        private ShaderConfig _config;
 
         private List<Operation> _operations;
 
         private Dictionary<ulong, Operand> _labels;
 
-        public EmitterContext(
-            ShaderStage        stage,
-            ShaderHeader       header,
-            ShaderCapabilities capabilities,
-            TranslationFlags   flags)
+        public EmitterContext(ShaderConfig config)
         {
-            _stage        = stage;
-            _header       = header;
-            _capabilities = capabilities;
-            _flags        = flags;
+            _config = config;
 
             _operations = new List<Operation>();
 
@@ -69,24 +59,24 @@ namespace Ryujinx.Graphics.Shader.Translation
 
         public void PrepareForReturn()
         {
-            if (_stage == ShaderStage.Vertex)
+            if (_config.Stage == ShaderStage.Vertex)
             {
-                if ((_flags & TranslationFlags.DividePosXY) != 0)
+                if (!_config.QueryInfoBool(QueryInfoName.ViewportTransformEnable))
                 {
                     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)));
+                    this.Copy(posX, this.FPDivide(posX, ConstF(_config.QueryInfo(QueryInfoName.MaximumViewportDimensions) / 2)));
+                    this.Copy(posY, this.FPDivide(posY, ConstF(_config.QueryInfo(QueryInfoName.MaximumViewportDimensions) / 2)));
                 }
             }
-            else if (_stage == ShaderStage.Fragment)
+            else if (_config.Stage == ShaderStage.Fragment)
             {
-                if (_header.OmapDepth)
+                if (_config.OmapDepth)
                 {
                     Operand dest = Attribute(AttributeConsts.FragmentOutputDepth);
 
-                    Operand src = Register(_header.DepthRegister, RegisterType.Gpr);
+                    Operand src = Register(_config.GetDepthRegister(), RegisterType.Gpr);
 
                     this.Copy(dest, src);
                 }
@@ -95,7 +85,7 @@ namespace Ryujinx.Graphics.Shader.Translation
 
                 for (int attachment = 0; attachment < 8; attachment++)
                 {
-                    OutputMapTarget target = _header.OmapTargets[attachment];
+                    OutputMapTarget target = _config.OmapTargets[attachment];
 
                     for (int component = 0; component < 4; component++)
                     {
diff --git a/Ryujinx.Graphics.Shader/Translation/Lowering.cs b/Ryujinx.Graphics.Shader/Translation/Lowering.cs
index 46884bc9..1ee21e0a 100644
--- a/Ryujinx.Graphics.Shader/Translation/Lowering.cs
+++ b/Ryujinx.Graphics.Shader/Translation/Lowering.cs
@@ -27,9 +27,9 @@ namespace Ryujinx.Graphics.Shader.Translation
                         node = RewriteGlobalAccess(node, config);
                     }
 
-                    if (!config.Capabilities.SupportsNonConstantTextureOffset && operation.Inst == Instruction.TextureSample)
+                    if (operation.Inst == Instruction.TextureSample)
                     {
-                        node = RewriteTextureSample(node);
+                        node = RewriteTextureSample(node, config);
                     }
                 }
             }
@@ -79,7 +79,7 @@ namespace Ryujinx.Graphics.Shader.Translation
                 sbSlot        = PrependOperation(Instruction.ConditionalSelect, inRange, Const(slot), sbSlot);
             }
 
-            Operand alignMask = Const(-config.Capabilities.StorageBufferOffsetAlignment);
+            Operand alignMask = Const(-config.QueryInfo(QueryInfoName.StorageBufferOffsetAlignment));
 
             Operand baseAddrTrunc = PrependOperation(Instruction.BitwiseAnd,    sbBaseAddrLow, Const(-64));
             Operand byteOffset    = PrependOperation(Instruction.Subtract,      addrLow, baseAddrTrunc);
@@ -124,23 +124,18 @@ namespace Ryujinx.Graphics.Shader.Translation
             return node;
         }
 
-        private static LinkedListNode<INode> RewriteTextureSample(LinkedListNode<INode> node)
+        private static LinkedListNode<INode> RewriteTextureSample(LinkedListNode<INode> node, ShaderConfig config)
         {
-            // Technically, non-constant texture offsets are not allowed (according to the spec),
-            // however some GPUs does support that.
-            // For GPUs where it is not supported, we can replace the instruction with the following:
-            // For texture*Offset, we replace it by texture*, and add the offset to the P coords.
-            // The offset can be calculated as offset / textureSize(lod), where lod = textureQueryLod(coords).
-            // For texelFetchOffset, we replace it by texelFetch and add the offset to the P coords directly.
-            // For textureGatherOffset, we take advantage of the fact that the operation is already broken down
-            // to read the 4 pixels separately, and just replace it with 4 textureGather with a different offset
-            // for each pixel.
             TextureOperation texOp = (TextureOperation)node.Value;
 
             bool hasOffset  = (texOp.Flags & TextureFlags.Offset)  != 0;
             bool hasOffsets = (texOp.Flags & TextureFlags.Offsets) != 0;
 
-            if (!(hasOffset || hasOffsets))
+            bool hasInvalidOffset = (hasOffset || hasOffsets) && !config.QueryInfoBool(QueryInfoName.SupportsNonConstantTextureOffset);
+
+            bool isRect = config.QueryInfoBool(QueryInfoName.IsTextureRectangle, texOp.Handle);
+
+            if (!(hasInvalidOffset || isRect))
             {
                 return node;
             }
@@ -159,14 +154,24 @@ namespace Ryujinx.Graphics.Shader.Translation
 
             int coordsCount = texOp.Type.GetDimensions();
 
-            int offsetsCount = coordsCount * (hasOffsets ? 4 : 1);
+            int offsetsCount;
+
+            if (hasOffsets)
+            {
+                offsetsCount = coordsCount * 4;
+            }
+            else if (hasOffset)
+            {
+                offsetsCount = coordsCount;
+            }
+            else
+            {
+                offsetsCount = 0;
+            }
 
             Operand[] offsets = new Operand[offsetsCount];
             Operand[] sources = new Operand[texOp.SourcesCount - offsetsCount];
 
-            int srcIndex = 0;
-            int dstIndex = 0;
-
             int copyCount = 0;
 
             if (isBindless || isIndexed)
@@ -207,6 +212,9 @@ namespace Ryujinx.Graphics.Shader.Translation
                 copyCount++;
             }
 
+            int srcIndex = 0;
+            int dstIndex = 0;
+
             for (int index = 0; index < copyCount; index++)
             {
                 sources[dstIndex++] = texOp.GetSource(srcIndex++);
@@ -223,7 +231,9 @@ namespace Ryujinx.Graphics.Shader.Translation
                 offsets[index] = offset;
             }
 
-            if (areAllOffsetsConstant)
+            hasInvalidOffset &= !areAllOffsetsConstant;
+
+            if (!(hasInvalidOffset || isRect))
             {
                 return node;
             }
@@ -240,50 +250,32 @@ namespace Ryujinx.Graphics.Shader.Translation
 
             int coordsIndex = isBindless || isIndexed ? 1 : 0;
 
-            if (intCoords)
-            {
-                for (int index = 0; index < coordsCount; index++)
-                {
-                    Operand source = sources[coordsIndex + index];
-
-                    Operand coordPlusOffset = Local();
+            int componentIndex = texOp.Index;
 
-                    node.List.AddBefore(node, new Operation(Instruction.Add, coordPlusOffset, source, offsets[index]));
-
-                    sources[coordsIndex + index] = coordPlusOffset;
-                }
-            }
-            else
+            Operand Int(Operand value)
             {
-                Operand lod = Local();
-
-                node.List.AddBefore(node, new TextureOperation(
-                    Instruction.Lod,
-                    texOp.Type,
-                    texOp.Flags,
-                    texOp.Handle,
-                    1,
-                    lod,
-                    lodSources));
-
-                Operand Int(Operand value)
-                {
-                    Operand res = Local();
+                Operand res = Local();
 
-                    node.List.AddBefore(node, new Operation(Instruction.ConvertFPToS32, res, value));
+                node.List.AddBefore(node, new Operation(Instruction.ConvertFPToS32, res, value));
 
-                    return res;
-                }
+                return res;
+            }
 
-                Operand Float(Operand value)
-                {
-                    Operand res = Local();
+            Operand Float(Operand value)
+            {
+                Operand res = Local();
 
-                    node.List.AddBefore(node, new Operation(Instruction.ConvertS32ToFP, res, value));
+                node.List.AddBefore(node, new Operation(Instruction.ConvertS32ToFP, res, value));
 
-                    return res;
-                }
+                return res;
+            }
 
+            // Emulate texture rectangle by normalizing the coordinates on the shader.
+            // When sampler*Rect is used, the coords are expected to the in the [0, W or H] range,
+            // and otherwise, it is expected to be in the [0, 1] range.
+            // We normalize by dividing the coords by the texture size.
+            if (isRect && !intCoords)
+            {
                 for (int index = 0; index < coordsCount; index++)
                 {
                     Operand coordSize = Local();
@@ -292,11 +284,11 @@ namespace Ryujinx.Graphics.Shader.Translation
 
                     if (isBindless || isIndexed)
                     {
-                        texSizeSources = new Operand[] { sources[0], Int(lod) };
+                        texSizeSources = new Operand[] { sources[0], Const(0) };
                     }
                     else
                     {
-                        texSizeSources = new Operand[] { Int(lod) };
+                        texSizeSources = new Operand[] { Const(0) };
                     }
 
                     node.List.AddBefore(node, new TextureOperation(
@@ -308,35 +300,101 @@ namespace Ryujinx.Graphics.Shader.Translation
                         coordSize,
                         texSizeSources));
 
-                    Operand offset = Local();
+                    Operand source = sources[coordsIndex + index];
+
+                    Operand coordNormalized = Local();
 
-                    Operand intOffset = offsets[index + (hasOffsets ? texOp.Index * coordsCount : 0)];
+                    node.List.AddBefore(node, new Operation(Instruction.FP | Instruction.Divide, coordNormalized, source, Float(coordSize)));
 
-                    node.List.AddBefore(node, new Operation(Instruction.FP | Instruction.Divide, offset, Float(intOffset), Float(coordSize)));
+                    sources[coordsIndex + index] = coordNormalized;
+                }
+            }
 
-                    Operand source = sources[coordsIndex + index];
+            // Technically, non-constant texture offsets are not allowed (according to the spec),
+            // however some GPUs does support that.
+            // For GPUs where it is not supported, we can replace the instruction with the following:
+            // For texture*Offset, we replace it by texture*, and add the offset to the P coords.
+            // The offset can be calculated as offset / textureSize(lod), where lod = textureQueryLod(coords).
+            // For texelFetchOffset, we replace it by texelFetch and add the offset to the P coords directly.
+            // For textureGatherOffset, we take advantage of the fact that the operation is already broken down
+            // to read the 4 pixels separately, and just replace it with 4 textureGather with a different offset
+            // for each pixel.
+            if (hasInvalidOffset)
+            {
+                if (intCoords)
+                {
+                    for (int index = 0; index < coordsCount; index++)
+                    {
+                        Operand source = sources[coordsIndex + index];
 
-                    Operand coordPlusOffset = Local();
+                        Operand coordPlusOffset = Local();
 
-                    node.List.AddBefore(node, new Operation(Instruction.FP | Instruction.Add, coordPlusOffset, source, offset));
+                        node.List.AddBefore(node, new Operation(Instruction.Add, coordPlusOffset, source, offsets[index]));
 
-                    sources[coordsIndex + index] = coordPlusOffset;
+                        sources[coordsIndex + index] = coordPlusOffset;
+                    }
                 }
-            }
+                else
+                {
+                    Operand lod = Local();
+
+                    node.List.AddBefore(node, new TextureOperation(
+                        Instruction.Lod,
+                        texOp.Type,
+                        texOp.Flags,
+                        texOp.Handle,
+                        1,
+                        lod,
+                        lodSources));
 
-            int componentIndex;
+                    for (int index = 0; index < coordsCount; index++)
+                    {
+                        Operand coordSize = Local();
 
-            if (isGather && !isShadow)
-            {
-                Operand gatherComponent = sources[dstIndex - 1];
+                        Operand[] texSizeSources;
 
-                Debug.Assert(gatherComponent.Type == OperandType.Constant);
+                        if (isBindless || isIndexed)
+                        {
+                            texSizeSources = new Operand[] { sources[0], Int(lod) };
+                        }
+                        else
+                        {
+                            texSizeSources = new Operand[] { Int(lod) };
+                        }
 
-                componentIndex = gatherComponent.Value;
-            }
-            else
-            {
-                componentIndex = texOp.Index;
+                        node.List.AddBefore(node, new TextureOperation(
+                            Instruction.TextureSize,
+                            texOp.Type,
+                            texOp.Flags,
+                            texOp.Handle,
+                            index,
+                            coordSize,
+                            texSizeSources));
+
+                        Operand offset = Local();
+
+                        Operand intOffset = offsets[index + (hasOffsets ? texOp.Index * coordsCount : 0)];
+
+                        node.List.AddBefore(node, new Operation(Instruction.FP | Instruction.Divide, offset, Float(intOffset), Float(coordSize)));
+
+                        Operand source = sources[coordsIndex + index];
+
+                        Operand coordPlusOffset = Local();
+
+                        node.List.AddBefore(node, new Operation(Instruction.FP | Instruction.Add, coordPlusOffset, source, offset));
+
+                        sources[coordsIndex + index] = coordPlusOffset;
+                    }
+                }
+
+                if (isGather && !isShadow)
+                {
+                    Operand gatherComponent = sources[dstIndex - 1];
+
+                    Debug.Assert(gatherComponent.Type == OperandType.Constant);
+
+                    componentIndex = gatherComponent.Value;
+                }
             }
 
             TextureOperation newTexOp = new TextureOperation(
diff --git a/Ryujinx.Graphics.Shader/Translation/Optimizations/GlobalToStorage.cs b/Ryujinx.Graphics.Shader/Translation/Optimizations/GlobalToStorage.cs
index 639f9ba4..59261fbf 100644
--- a/Ryujinx.Graphics.Shader/Translation/Optimizations/GlobalToStorage.cs
+++ b/Ryujinx.Graphics.Shader/Translation/Optimizations/GlobalToStorage.cs
@@ -52,7 +52,7 @@ namespace Ryujinx.Graphics.Shader.Translation.Optimizations
 
                 Operand baseAddrTrunc = Local();
 
-                Operand alignMask = Const(-config.Capabilities.StorageBufferOffsetAlignment);
+                Operand alignMask = Const(-config.QueryInfo(QueryInfoName.StorageBufferOffsetAlignment));
 
                 Operation andOp = new Operation(Instruction.BitwiseAnd, baseAddrTrunc, baseAddrLow, alignMask);
 
diff --git a/Ryujinx.Graphics.Shader/Translation/TranslationFlags.cs b/Ryujinx.Graphics.Shader/Translation/TranslationFlags.cs
index 8faa4383..1327abae 100644
--- a/Ryujinx.Graphics.Shader/Translation/TranslationFlags.cs
+++ b/Ryujinx.Graphics.Shader/Translation/TranslationFlags.cs
@@ -4,9 +4,7 @@ namespace Ryujinx.Graphics.Shader.Translation
     {
         None = 0,
 
-        Compute       = 1 << 0,
-        DebugMode     = 1 << 1,
-        Unspecialized = 1 << 2,
-        DividePosXY   = 1 << 3
+        Compute   = 1 << 0,
+        DebugMode = 1 << 1
     }
 }
\ No newline at end of file
diff --git a/Ryujinx.Graphics.Shader/Translation/Translator.cs b/Ryujinx.Graphics.Shader/Translation/Translator.cs
index 69e63ae1..af209edf 100644
--- a/Ryujinx.Graphics.Shader/Translation/Translator.cs
+++ b/Ryujinx.Graphics.Shader/Translation/Translator.cs
@@ -16,14 +16,7 @@ namespace Ryujinx.Graphics.Shader.Translation
 
         public static Span<byte> ExtractCode(Span<byte> code, bool compute, out int headerSize)
         {
-            if (compute)
-            {
-                headerSize = 0;
-            }
-            else
-            {
-                headerSize = HeaderSize;
-            }
+            headerSize = compute ? 0 : HeaderSize;
 
             Block[] cfg = Decoder.Decode(code, (ulong)headerSize);
 
@@ -47,56 +40,21 @@ namespace Ryujinx.Graphics.Shader.Translation
             return code.Slice(0, headerSize + (int)endAddress);
         }
 
-        public static ShaderProgram Translate(Span<byte> code, ShaderCapabilities capabilities, TranslationFlags flags)
+        public static ShaderProgram Translate(Span<byte> code, QueryInfoCallback queryInfoCallback, TranslationFlags flags)
         {
             bool compute = (flags & TranslationFlags.Compute) != 0;
 
-            Operation[] ops = DecodeShader(code, capabilities, flags, out ShaderHeader header, out int size);
-
-            ShaderStage stage;
-
-            if (compute)
-            {
-                stage = ShaderStage.Compute;
-            }
-            else
-            {
-                stage = header.Stage;
-            }
-
-            int maxOutputVertexCount = 0;
-
-            OutputTopology outputTopology = OutputTopology.LineStrip;
-
-            if (!compute)
-            {
-                maxOutputVertexCount = header.MaxOutputVertexCount;
-                outputTopology       = header.OutputTopology;
-            }
-
-            ShaderConfig config = new ShaderConfig(
-                stage,
-                capabilities,
-                flags,
-                maxOutputVertexCount,
-                outputTopology);
+            Operation[] ops = DecodeShader(code, queryInfoCallback, flags, out ShaderConfig config, out int size);
 
             return Translate(ops, config, size);
         }
 
-        public static ShaderProgram Translate(Span<byte> vpACode, Span<byte> vpBCode, ShaderCapabilities capabilities, TranslationFlags flags)
+        public static ShaderProgram Translate(Span<byte> vpACode, Span<byte> vpBCode, QueryInfoCallback queryInfoCallback, TranslationFlags flags)
         {
             bool debugMode = (flags & TranslationFlags.DebugMode) != 0;
 
-            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,
-                capabilities,
-                flags,
-                header.MaxOutputVertexCount,
-                header.OutputTopology);
+            Operation[] vpAOps = DecodeShader(vpACode, queryInfoCallback, flags, out _, out _);
+            Operation[] vpBOps = DecodeShader(vpBCode, queryInfoCallback, flags, out ShaderConfig config, out int sizeB);
 
             return Translate(Combine(vpAOps, vpBOps), config, sizeB);
         }
@@ -136,31 +94,25 @@ namespace Ryujinx.Graphics.Shader.Translation
         }
 
         private static Operation[] DecodeShader(
-            Span<byte>         code,
-            ShaderCapabilities capabilities,
-            TranslationFlags   flags,
-            out ShaderHeader   header,
-            out int            size)
+            Span<byte>        code,
+            QueryInfoCallback queryInfoCallback,
+            TranslationFlags  flags,
+            out ShaderConfig  config,
+            out int           size)
         {
             Block[] cfg;
 
-            EmitterContext context;
-
             if ((flags & TranslationFlags.Compute) != 0)
             {
-                header = null;
+                config = new ShaderConfig(flags, queryInfoCallback);
 
                 cfg = Decoder.Decode(code, 0);
-
-                context = new EmitterContext(ShaderStage.Compute, header, capabilities, flags);
             }
             else
             {
-                header = new ShaderHeader(code);
+                config = new ShaderConfig(new ShaderHeader(code), flags, queryInfoCallback);
 
                 cfg = Decoder.Decode(code, HeaderSize);
-
-                context = new EmitterContext(header.Stage, header, capabilities, flags);
             }
 
             if (cfg == null)
@@ -172,6 +124,8 @@ namespace Ryujinx.Graphics.Shader.Translation
                 return new Operation[0];
             }
 
+            EmitterContext context = new EmitterContext(config);
+
             ulong maxEndAddress = 0;
 
             for (int blkIndex = 0; blkIndex < cfg.Length; blkIndex++)