Support texture rectangle targets (non-normalized coords)

5 files changed, 162 insertions, 162 deletions

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++)