New shader translator implementation (#654)

* Start implementing a new shader translator

* Fix shift instructions and a typo

* Small refactoring on StructuredProgram, move RemovePhis method to a separate class

* Initial geometry shader support

* Implement TLD4

* Fix -- There's no negation on FMUL32I

* Add constant folding and algebraic simplification optimizations, nits

* Some leftovers from constant folding

* Avoid cast for constant assignments

* Add a branch elimination pass, and misc small fixes

* Remove redundant branches, add expression propagation and other improvements on the code

* Small leftovers -- add missing break and continue, remove unused properties, other improvements

* Add null check to handle empty block cases on block visitor

* Add HADD2 and HMUL2 half float shader instructions

* Optimize pack/unpack sequences, some fixes related to half float instructions

* Add TXQ, TLD, TLDS and TLD4S shader texture instructions, and some support for bindless textures, some refactoring on codegen

* Fix copy paste mistake that caused RZ to be ignored on the AST instruction

* Add workaround for conditional exit, and fix half float instruction with constant buffer

* Add missing 0.0 source for TLDS.LZ variants

* Simplify the switch for TLDS.LZ

* Texture instructions related fixes

* Implement the HFMA instruction, and some misc. fixes

* Enable constant folding on UnpackHalf2x16 instructions

* Refactor HFMA to use OpCode* for opcode decoding rather than on the helper methods

* Remove the old shader translator

* Remove ShaderDeclInfo and other unused things

* Add dual vertex shader support

* Add ShaderConfig, used to pass shader type and maximum cbuffer size

* Move and rename some instruction enums

* Move texture instructions into a separate file

* Move operand GetExpression and locals management to OperandManager

* Optimize opcode decoding using a simple list and binary search

* Add missing condition for do-while on goto elimination

* Misc. fixes on texture instructions

* Simplify TLDS switch

* Address PR feedback, and a nit

1 files changed, 149 insertions, 0 deletions

diff --git a/Ryujinx.Graphics/Shader/Instructions/Lop3Expression.cs b/Ryujinx.Graphics/Shader/Instructions/Lop3Expression.cs
new file mode 100644
index 00000000..e55ed660
--- /dev/null
+++ b/Ryujinx.Graphics/Shader/Instructions/Lop3Expression.cs
@@ -0,0 +1,149 @@
+using Ryujinx.Graphics.Shader.IntermediateRepresentation;
+using Ryujinx.Graphics.Shader.Translation;
+
+using static Ryujinx.Graphics.Shader.IntermediateRepresentation.OperandHelper;
+
+namespace Ryujinx.Graphics.Shader.Instructions
+{
+    static class Lop3Expression
+    {
+        public static Operand GetFromTruthTable(
+            EmitterContext context,
+            Operand        srcA,
+            Operand        srcB,
+            Operand        srcC,
+            int            imm)
+        {
+            Operand expr = null;
+
+            //Handle some simple cases, or cases where
+            //the KMap would yield poor results (like XORs).
+            if (imm == 0x96 || imm == 0x69)
+            {
+                //XOR (0x96) and XNOR (0x69).
+                if (imm == 0x69)
+                {
+                    srcA = context.BitwiseNot(srcA);
+                }
+
+                expr = context.BitwiseExclusiveOr(srcA, srcB);
+                expr = context.BitwiseExclusiveOr(expr, srcC);
+
+                return expr;
+            }
+            else if (imm == 0)
+            {
+                //Always false.
+                return Const(IrConsts.False);
+            }
+            else if (imm == 0xff)
+            {
+                //Always true.
+                return Const(IrConsts.True);
+            }
+
+            int map;
+
+            //Encode into gray code.
+            map  = ((imm >> 0) & 1) << 0;
+            map |= ((imm >> 1) & 1) << 4;
+            map |= ((imm >> 2) & 1) << 1;
+            map |= ((imm >> 3) & 1) << 5;
+            map |= ((imm >> 4) & 1) << 3;
+            map |= ((imm >> 5) & 1) << 7;
+            map |= ((imm >> 6) & 1) << 2;
+            map |= ((imm >> 7) & 1) << 6;
+
+            //Solve KMap, get sum of products.
+            int visited = 0;
+
+            for (int index = 0; index < 8 && visited != 0xff; index++)
+            {
+                if ((map & (1 << index)) == 0)
+                {
+                    continue;
+                }
+
+                int mask = 0;
+
+                for (int mSize = 4; mSize != 0; mSize >>= 1)
+                {
+                    mask = RotateLeft4((1 << mSize) - 1, index & 3) << (index & 4);
+
+                    if ((map & mask) == mask)
+                    {
+                        break;
+                    }
+                }
+
+                //The mask should wrap, if we are on the high row, shift to low etc.
+                int mask2 = (index & 4) != 0 ? mask >> 4 : mask << 4;
+
+                if ((map & mask2) == mask2)
+                {
+                    mask |= mask2;
+                }
+
+                if ((mask & visited) == mask)
+                {
+                    continue;
+                }
+
+                bool notA = (mask & 0x33) != 0;
+                bool notB = (mask & 0x99) != 0;
+                bool notC = (mask & 0x0f) != 0;
+
+                bool aChanges = (mask & 0xcc) != 0 && notA;
+                bool bChanges = (mask & 0x66) != 0 && notB;
+                bool cChanges = (mask & 0xf0) != 0 && notC;
+
+                Operand localExpr = null;
+
+                void And(Operand source)
+                {
+                    if (localExpr != null)
+                    {
+                        localExpr = context.BitwiseAnd(localExpr, source);
+                    }
+                    else
+                    {
+                        localExpr = source;
+                    }
+                }
+
+                if (!aChanges)
+                {
+                    And(context.BitwiseNot(srcA, notA));
+                }
+
+                if (!bChanges)
+                {
+                    And(context.BitwiseNot(srcB, notB));
+                }
+
+                if (!cChanges)
+                {
+                    And(context.BitwiseNot(srcC, notC));
+                }
+
+                if (expr != null)
+                {
+                    expr = context.BitwiseOr(expr, localExpr);
+                }
+                else
+                {
+                    expr = localExpr;
+                }
+
+                visited |= mask;
+            }
+
+            return expr;
+        }
+
+        private static int RotateLeft4(int value, int shift)
+        {
+            return ((value << shift) | (value >> (4 - shift))) & 0xf;
+        }
+    }
+}
\ No newline at end of file