1 files changed, 219 insertions, 0 deletions
diff --git a/Ryujinx.Graphics/Shader/Translation/Translator.cs b/Ryujinx.Graphics/Shader/Translation/Translator.cs
new file mode 100644
index 00000000..706f3cfa
--- /dev/null
+++ b/Ryujinx.Graphics/Shader/Translation/Translator.cs
@@ -0,0 +1,219 @@
+using Ryujinx.Graphics.Gal;
+using Ryujinx.Graphics.Shader.CodeGen.Glsl;
+using Ryujinx.Graphics.Shader.Decoders;
+using Ryujinx.Graphics.Shader.Instructions;
+using Ryujinx.Graphics.Shader.IntermediateRepresentation;
+using Ryujinx.Graphics.Shader.StructuredIr;
+using Ryujinx.Graphics.Shader.Translation.Optimizations;
+using System.Collections.Generic;
+
+using static Ryujinx.Graphics.Shader.IntermediateRepresentation.OperandHelper;
+
+namespace Ryujinx.Graphics.Shader.Translation
+{
+    public static class Translator
+    {
+        public static ShaderProgram Translate(IGalMemory memory, ulong address, ShaderConfig config)
+        {
+            return Translate(memory, address, 0, config);
+        }
+
+        public static ShaderProgram Translate(
+            IGalMemory   memory,
+            ulong        address,
+            ulong        addressB,
+            ShaderConfig config)
+        {
+            Operation[] shaderOps = DecodeShader(memory, address, config.Type);
+
+            if (addressB != 0)
+            {
+                //Dual vertex shader.
+                Operation[] shaderOpsB = DecodeShader(memory, addressB, config.Type);
+
+                shaderOps = Combine(shaderOps, shaderOpsB);
+            }
+
+            BasicBlock[] irBlocks = ControlFlowGraph.MakeCfg(shaderOps);
+
+            Dominance.FindDominators(irBlocks[0], irBlocks.Length);
+
+            Dominance.FindDominanceFrontiers(irBlocks);
+
+            Ssa.Rename(irBlocks);
+
+            Optimizer.Optimize(irBlocks);
+
+            StructuredProgramInfo sInfo = StructuredProgram.MakeStructuredProgram(irBlocks);
+
+            GlslProgram program = GlslGenerator.Generate(sInfo, config);
+
+            ShaderProgramInfo spInfo = new ShaderProgramInfo(
+                program.CBufferDescriptors,
+                program.TextureDescriptors);
+
+            return new ShaderProgram(spInfo, program.Code);
+        }
+
+        private static Operation[] DecodeShader(IGalMemory memory, ulong address, GalShaderType shaderType)
+        {
+            ShaderHeader header = new ShaderHeader(memory, address);
+
+            Block[] cfg = Decoder.Decode(memory, address);
+
+            EmitterContext context = new EmitterContext(shaderType, header);
+
+            for (int blkIndex = 0; blkIndex < cfg.Length; blkIndex++)
+            {
+                Block block = cfg[blkIndex];
+
+                context.CurrBlock = block;
+
+                context.MarkLabel(context.GetLabel(block.Address));
+
+                for (int opIndex = 0; opIndex < block.OpCodes.Count; opIndex++)
+                {
+                    OpCode op = block.OpCodes[opIndex];
+
+                    if (op.NeverExecute)
+                    {
+                        continue;
+                    }
+
+                    Operand predSkipLbl = null;
+
+                    bool skipPredicateCheck = op.Emitter == InstEmit.Bra;
+
+                    if (op is OpCodeSync opSync)
+                    {
+                        //If the instruction is a SYNC instruction with only one
+                        //possible target address, then the instruction is basically
+                        //just a simple branch, we can generate code similar to branch
+                        //instructions, with the condition check on the branch itself.
+                        skipPredicateCheck |= opSync.Targets.Count < 2;
+                    }
+
+                    if (!(op.Predicate.IsPT || skipPredicateCheck))
+                    {
+                        Operand label;
+
+                        if (opIndex == block.OpCodes.Count - 1 && block.Next != null)
+                        {
+                            label = context.GetLabel(block.Next.Address);
+                        }
+                        else
+                        {
+                            label = Label();
+
+                            predSkipLbl = label;
+                        }
+
+                        Operand pred = Register(op.Predicate);
+
+                        if (op.InvertPredicate)
+                        {
+                            context.BranchIfTrue(label, pred);
+                        }
+                        else
+                        {
+                            context.BranchIfFalse(label, pred);
+                        }
+                    }
+
+                    context.CurrOp = op;
+
+                    op.Emitter(context);
+
+                    if (predSkipLbl != null)
+                    {
+                        context.MarkLabel(predSkipLbl);
+                    }
+                }
+            }
+
+            return context.GetOperations();
+        }
+
+        private static Operation[] Combine(Operation[] a, Operation[] b)
+        {
+            //Here we combine two shaders.
+            //For shader A:
+            //- All user attribute stores on shader A are turned into copies to a
+            //temporary variable. It's assumed that shader B will consume them.
+            //- All return instructions are turned into branch instructions, the
+            //branch target being the start of the shader B code.
+            //For shader B:
+            //- All user attribute loads on shader B are turned into copies from a
+            //temporary variable, as long that attribute is written by shader A.
+            List<Operation> output = new List<Operation>(a.Length + b.Length);
+
+            Operand[] temps = new Operand[AttributeConsts.UserAttributesCount * 4];
+
+            Operand lblB = Label();
+
+            for (int index = 0; index < a.Length; index++)
+            {
+                Operation operation = a[index];
+
+                if (IsUserAttribute(operation.Dest))
+                {
+                    int tIndex = (operation.Dest.Value - AttributeConsts.UserAttributeBase) / 4;
+
+                    Operand temp = temps[tIndex];
+
+                    if (temp == null)
+                    {
+                        temp = Local();
+
+                        temps[tIndex] = temp;
+                    }
+
+                    operation.Dest = temp;
+                }
+
+                if (operation.Inst == Instruction.Return)
+                {
+                    output.Add(new Operation(Instruction.Branch, lblB));
+                }
+                else
+                {
+                    output.Add(operation);
+                }
+            }
+
+            output.Add(new Operation(Instruction.MarkLabel, lblB));
+
+            for (int index = 0; index < b.Length; index++)
+            {
+                Operation operation = b[index];
+
+                for (int srcIndex = 0; srcIndex < operation.SourcesCount; srcIndex++)
+                {
+                    Operand src = operation.GetSource(srcIndex);
+
+                    if (IsUserAttribute(src))
+                    {
+                        Operand temp = temps[(src.Value - AttributeConsts.UserAttributeBase) / 4];
+
+                        if (temp != null)
+                        {
+                            operation.SetSource(srcIndex, temp);
+                        }
+                    }
+                }
+
+                output.Add(operation);
+            }
+
+            return output.ToArray();
+        }
+
+        private static bool IsUserAttribute(Operand operand)
+        {
+            return operand != null &&
+                   operand.Type == OperandType.Attribute &&
+                   operand.Value >= AttributeConsts.UserAttributeBase &&
+                   operand.Value <  AttributeConsts.UserAttributeEnd;
+        }
+    }
+}
+\ No newline at end of file