aboutsummaryrefslogtreecommitdiff
path: root/src/Ryujinx.Graphics.Shader/Instructions/InstEmitMultifunction.cs
blob: 5c079378e4da5ab1dd1880ab91ab35a058218a9f (plain) (blame)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
using Ryujinx.Graphics.Shader.Decoders;
using Ryujinx.Graphics.Shader.IntermediateRepresentation;
using Ryujinx.Graphics.Shader.Translation;

using static Ryujinx.Graphics.Shader.Instructions.InstEmitHelper;

namespace Ryujinx.Graphics.Shader.Instructions
{
    static partial class InstEmit
    {
        public static void RroR(EmitterContext context)
        {
            InstRroR op = context.GetOp<InstRroR>();

            EmitRro(context, GetSrcReg(context, op.SrcB), op.Dest, op.AbsB, op.NegB);
        }

        public static void RroI(EmitterContext context)
        {
            InstRroI op = context.GetOp<InstRroI>();

            EmitRro(context, GetSrcImm(context, Imm20ToFloat(op.Imm20)), op.Dest, op.AbsB, op.NegB);
        }

        public static void RroC(EmitterContext context)
        {
            InstRroC op = context.GetOp<InstRroC>();

            EmitRro(context, GetSrcCbuf(context, op.CbufSlot, op.CbufOffset), op.Dest, op.AbsB, op.NegB);
        }

        public static void Mufu(EmitterContext context)
        {
            InstMufu op = context.GetOp<InstMufu>();

            Operand res = context.FPAbsNeg(GetSrcReg(context, op.SrcA), op.AbsA, op.NegA);

            switch (op.MufuOp)
            {
                case MufuOp.Cos:
                    res = context.FPCosine(res);
                    break;

                case MufuOp.Sin:
                    res = context.FPSine(res);
                    break;

                case MufuOp.Ex2:
                    res = context.FPExponentB2(res);
                    break;

                case MufuOp.Lg2:
                    res = context.FPLogarithmB2(res);
                    break;

                case MufuOp.Rcp:
                    res = context.FPReciprocal(res);
                    break;

                case MufuOp.Rsq:
                    res = context.FPReciprocalSquareRoot(res);
                    break;

                case MufuOp.Rcp64h:
                    res = context.PackDouble2x32(OperandHelper.Const(0), res);
                    res = context.UnpackDouble2x32High(context.FPReciprocal(res, Instruction.FP64));
                    break;

                case MufuOp.Rsq64h:
                    res = context.PackDouble2x32(OperandHelper.Const(0), res);
                    res = context.UnpackDouble2x32High(context.FPReciprocalSquareRoot(res, Instruction.FP64));
                    break;

                case MufuOp.Sqrt:
                    res = context.FPSquareRoot(res);
                    break;

                default:
                    context.TranslatorContext.GpuAccessor.Log($"Invalid MUFU operation \"{op.MufuOp}\".");
                    break;
            }

            context.Copy(GetDest(op.Dest), context.FPSaturate(res, op.Sat));
        }

        private static void EmitRro(EmitterContext context, Operand srcB, int rd, bool absB, bool negB)
        {
            // This is the range reduction operator,
            // we translate it as a simple move, as it
            // should be always followed by a matching
            // MUFU instruction.
            srcB = context.FPAbsNeg(srcB, absB, negB);

            context.Copy(GetDest(rd), srcB);
        }
    }
}