Ryujinx/Ryujinx.Graphics/Gal/Shader/GlslDecompiler.cs

using OpenTK.Graphics.OpenGL;
using Ryujinx.Graphics.Texture;
using System;
using System.Collections.Generic;
using System.Globalization;
using System.Linq;
using System.Text;

namespace Ryujinx.Graphics.Gal.Shader
{
    public class GlslDecompiler
    {
        private delegate string GetInstExpr(ShaderIrOp op);

        private Dictionary<ShaderIrInst, GetInstExpr> _instsExpr;

        private enum OperType
        {
            Bool,
            F32,
            I32
        }

        private const string IdentationStr = "    ";

        private const int MaxVertexInput = 3;

        private GlslDecl _decl;

        private ShaderHeader _header, _headerB;

        private ShaderIrBlock[] _blocks, _blocksB;

        private StringBuilder _sb;

        public int MaxUboSize { get; }

        private bool _isNvidiaDriver;

        public GlslDecompiler(int maxUboSize, bool isNvidiaDriver)
        {
            _instsExpr = new Dictionary<ShaderIrInst, GetInstExpr>()
            {
                { ShaderIrInst.Abs,    GetAbsExpr    },
                { ShaderIrInst.Add,    GetAddExpr    },
                { ShaderIrInst.And,    GetAndExpr    },
                { ShaderIrInst.Asr,    GetAsrExpr    },
                { ShaderIrInst.Band,   GetBandExpr   },
                { ShaderIrInst.Bnot,   GetBnotExpr   },
                { ShaderIrInst.Bor,    GetBorExpr    },
                { ShaderIrInst.Bxor,   GetBxorExpr   },
                { ShaderIrInst.Ceil,   GetCeilExpr   },
                { ShaderIrInst.Ceq,    GetCeqExpr    },
                { ShaderIrInst.Cge,    GetCgeExpr    },
                { ShaderIrInst.Cgt,    GetCgtExpr    },
                { ShaderIrInst.Clamps, GetClampsExpr },
                { ShaderIrInst.Clampu, GetClampuExpr },
                { ShaderIrInst.Cle,    GetCleExpr    },
                { ShaderIrInst.Clt,    GetCltExpr    },
                { ShaderIrInst.Cne,    GetCneExpr    },
                { ShaderIrInst.Cut,    GetCutExpr    },
                { ShaderIrInst.Exit,   GetExitExpr   },
                { ShaderIrInst.Fabs,   GetAbsExpr    },
                { ShaderIrInst.Fadd,   GetAddExpr    },
                { ShaderIrInst.Fceq,   GetCeqExpr    },
                { ShaderIrInst.Fcequ,  GetCequExpr   },
                { ShaderIrInst.Fcge,   GetCgeExpr    },
                { ShaderIrInst.Fcgeu,  GetCgeuExpr   },
                { ShaderIrInst.Fcgt,   GetCgtExpr    },
                { ShaderIrInst.Fcgtu,  GetCgtuExpr   },
                { ShaderIrInst.Fclamp, GetFclampExpr },
                { ShaderIrInst.Fcle,   GetCleExpr    },
                { ShaderIrInst.Fcleu,  GetCleuExpr   },
                { ShaderIrInst.Fclt,   GetCltExpr    },
                { ShaderIrInst.Fcltu,  GetCltuExpr   },
                { ShaderIrInst.Fcnan,  GetCnanExpr   },
                { ShaderIrInst.Fcne,   GetCneExpr    },
                { ShaderIrInst.Fcneu,  GetCneuExpr   },
                { ShaderIrInst.Fcnum,  GetCnumExpr   },
                { ShaderIrInst.Fcos,   GetFcosExpr   },
                { ShaderIrInst.Fex2,   GetFex2Expr   },
                { ShaderIrInst.Ffma,   GetFfmaExpr   },
                { ShaderIrInst.Flg2,   GetFlg2Expr   },
                { ShaderIrInst.Floor,  GetFloorExpr  },
                { ShaderIrInst.Fmax,   GetMaxExpr    },
                { ShaderIrInst.Fmin,   GetMinExpr    },
                { ShaderIrInst.Fmul,   GetMulExpr    },
                { ShaderIrInst.Fneg,   GetNegExpr    },
                { ShaderIrInst.Frcp,   GetFrcpExpr   },
                { ShaderIrInst.Frsq,   GetFrsqExpr   },
                { ShaderIrInst.Fsin,   GetFsinExpr   },
                { ShaderIrInst.Fsqrt,  GetFsqrtExpr  },
                { ShaderIrInst.Ftos,   GetFtosExpr   },
                { ShaderIrInst.Ftou,   GetFtouExpr   },
                { ShaderIrInst.Ipa,    GetIpaExpr    },
                { ShaderIrInst.Kil,    GetKilExpr    },
                { ShaderIrInst.Lsl,    GetLslExpr    },
                { ShaderIrInst.Lsr,    GetLsrExpr    },
                { ShaderIrInst.Max,    GetMaxExpr    },
                { ShaderIrInst.Min,    GetMinExpr    },
                { ShaderIrInst.Mul,    GetMulExpr    },
                { ShaderIrInst.Neg,    GetNegExpr    },
                { ShaderIrInst.Not,    GetNotExpr    },
                { ShaderIrInst.Or,     GetOrExpr     },
                { ShaderIrInst.Stof,   GetStofExpr   },
                { ShaderIrInst.Sub,    GetSubExpr    },
                { ShaderIrInst.Texb,   GetTexbExpr   },
                { ShaderIrInst.Texq,   GetTexqExpr   },
                { ShaderIrInst.Texs,   GetTexsExpr   },
                { ShaderIrInst.Tld4,   GetTld4Expr   },
                { ShaderIrInst.Trunc,  GetTruncExpr  },
                { ShaderIrInst.Txlf,   GetTxlfExpr   },
                { ShaderIrInst.Utof,   GetUtofExpr   },
                { ShaderIrInst.Xor,    GetXorExpr    }
            };

            MaxUboSize = maxUboSize / 16;
            _isNvidiaDriver = isNvidiaDriver;
        }

        public GlslProgram Decompile(
            IGalMemory    memory,
            long          vpAPosition,
            long          vpBPosition,
            GalShaderType shaderType)
        {
            _header  = new ShaderHeader(memory, vpAPosition);
            _headerB = new ShaderHeader(memory, vpBPosition);

            _blocks  = ShaderDecoder.Decode(memory, vpAPosition);
            _blocksB = ShaderDecoder.Decode(memory, vpBPosition);

            GlslDecl declVpA = new GlslDecl(_blocks,  shaderType, _header);
            GlslDecl declVpB = new GlslDecl(_blocksB, shaderType, _headerB);

            _decl = GlslDecl.Merge(declVpA, declVpB);

            return Decompile();
        }

        public GlslProgram Decompile(IGalMemory memory, long position, GalShaderType shaderType)
        {
            _header  = new ShaderHeader(memory, position);
            _headerB = null;

            _blocks  = ShaderDecoder.Decode(memory, position);
            _blocksB = null;

            _decl = new GlslDecl(_blocks, shaderType, _header);

            return Decompile();
        }

        private GlslProgram Decompile()
        {
            _sb = new StringBuilder();

            _sb.AppendLine("#version 410 core");

            PrintDeclHeader();
            PrintDeclTextures();
            PrintDeclUniforms();
            PrintDeclAttributes();
            PrintDeclInAttributes();
            PrintDeclOutAttributes();
            PrintDeclGprs();
            PrintDeclPreds();
            PrintDeclSsy();

            if (_blocksB != null)
            {
                PrintBlockScope(_blocks, GlslDecl.BasicBlockAName);

                _sb.AppendLine();

                PrintBlockScope(_blocksB, GlslDecl.BasicBlockBName);
            }
            else
            {
                PrintBlockScope(_blocks, GlslDecl.BasicBlockName);
            }

            _sb.AppendLine();

            PrintMain();

            string glslCode = _sb.ToString();

            List<ShaderDeclInfo> textureInfo = new List<ShaderDeclInfo>();

            textureInfo.AddRange(_decl.Textures.Values);
            textureInfo.AddRange(IterateCbTextures());

            return new GlslProgram(glslCode, textureInfo, _decl.Uniforms.Values);
        }

        private void PrintDeclHeader()
        {
            if (_decl.ShaderType == GalShaderType.Geometry)
            {
                int maxVertices = _header.MaxOutputVertexCount;

                string outputTopology;

                switch (_header.OutputTopology)
                {
                    case ShaderHeader.PointList:     outputTopology = "points";         break;
                    case ShaderHeader.LineStrip:     outputTopology = "line_strip";     break;
                    case ShaderHeader.TriangleStrip: outputTopology = "triangle_strip"; break;

                    default: throw new InvalidOperationException();
                }

                _sb.AppendLine("#extension GL_ARB_enhanced_layouts : require");

                _sb.AppendLine();

                _sb.AppendLine("// Stubbed. Maxwell geometry shaders don't inform input geometry type");

                _sb.AppendLine("layout(triangles) in;" + Environment.NewLine);

                _sb.AppendLine($"layout({outputTopology}, max_vertices = {maxVertices}) out;");

                _sb.AppendLine();
            }
        }

        private string GetSamplerType(TextureTarget textureTarget, bool hasShadow)
        {
            string result;

            switch (textureTarget)
            {
                case TextureTarget.Texture1D:
                    result = "sampler1D";
                    break;
                case TextureTarget.Texture2D:
                    result = "sampler2D";
                    break;
                case TextureTarget.Texture3D:
                    result = "sampler3D";
                    break;
                case TextureTarget.TextureCubeMap:
                    result = "samplerCube";
                    break;
                case TextureTarget.TextureRectangle:
                    result = "sampler2DRect";
                    break;
                case TextureTarget.Texture1DArray:
                    result = "sampler1DArray";
                    break;
                case TextureTarget.Texture2DArray:
                    result = "sampler2DArray";
                    break;
                case TextureTarget.TextureCubeMapArray:
                    result = "samplerCubeArray";
                    break;
                case TextureTarget.TextureBuffer:
                    result = "samplerBuffer";
                    break;
                case TextureTarget.Texture2DMultisample:
                    result = "sampler2DMS";
                    break;
                case TextureTarget.Texture2DMultisampleArray:
                    result = "sampler2DMSArray";
                    break;
                default:
                    throw new NotSupportedException();
            }

            if (hasShadow)
                result += "Shadow";

            return result;
        }

        private void PrintDeclTextures()
        {
            foreach (ShaderDeclInfo declInfo in IterateCbTextures())
            {
                TextureTarget target = ImageUtils.GetTextureTarget(declInfo.TextureTarget);
                _sb.AppendLine($"// {declInfo.TextureSuffix}");
                _sb.AppendLine("uniform " + GetSamplerType(target, (declInfo.TextureSuffix & TextureInstructionSuffix.Dc) != 0) + " " + declInfo.Name + ";");
            }

            foreach (ShaderDeclInfo declInfo in _decl.Textures.Values.OrderBy(DeclKeySelector))
            {
                TextureTarget target = ImageUtils.GetTextureTarget(declInfo.TextureTarget);
                _sb.AppendLine($"// {declInfo.TextureSuffix}");
                _sb.AppendLine("uniform " + GetSamplerType(target, (declInfo.TextureSuffix & TextureInstructionSuffix.Dc) != 0) + " " + declInfo.Name + ";");
            }
        }

        private IEnumerable<ShaderDeclInfo> IterateCbTextures()
        {
            HashSet<string> names = new HashSet<string>();

            foreach (ShaderDeclInfo declInfo in _decl.CbTextures.Values.OrderBy(DeclKeySelector))
            {
                if (names.Add(declInfo.Name))
                {
                    yield return declInfo;
                }
            }
        }

        private void PrintDeclUniforms()
        {
            if (_decl.ShaderType == GalShaderType.Vertex)
            {
                //Memory layout here is [flip_x, flip_y, instance, unused]
                //It's using 4 bytes, not 8

                _sb.AppendLine("layout (std140) uniform " + GlslDecl.ExtraUniformBlockName + " {");

                _sb.AppendLine(IdentationStr + "vec2 " + GlslDecl.FlipUniformName + ";");

                _sb.AppendLine(IdentationStr + "int " + GlslDecl.InstanceUniformName + ";");

                _sb.AppendLine("};");
                _sb.AppendLine();
            }

            foreach (ShaderDeclInfo declInfo in _decl.Uniforms.Values.OrderBy(DeclKeySelector))
            {
                _sb.AppendLine($"layout (std140) uniform {declInfo.Name} {{");

                _sb.AppendLine($"{IdentationStr}vec4 {declInfo.Name}_data[{MaxUboSize}];");

                _sb.AppendLine("};");
            }

            if (_decl.Uniforms.Count > 0)
            {
                _sb.AppendLine();
            }
        }

        private void PrintDeclAttributes()
        {
            string geometryArray = (_decl.ShaderType == GalShaderType.Geometry) ? "[" + MaxVertexInput + "]" : "";

            PrintDecls(_decl.Attributes, suffix: geometryArray);
        }

        private void PrintDeclInAttributes()
        {
            if (_decl.ShaderType == GalShaderType.Fragment)
            {
                _sb.AppendLine("layout (location = " + GlslDecl.PositionOutAttrLocation + ") in vec4 " + GlslDecl.PositionOutAttrName + ";");
            }

            if (_decl.ShaderType == GalShaderType.Geometry)
            {
                if (_decl.InAttributes.Count > 0)
                {
                    _sb.AppendLine("in Vertex {");

                    foreach (ShaderDeclInfo declInfo in _decl.InAttributes.Values.OrderBy(DeclKeySelector))
                    {
                        if (declInfo.Index >= 0)
                        {
                            _sb.AppendLine(IdentationStr + "layout (location = " + declInfo.Index + ") vec4 " + declInfo.Name + "; ");
                        }
                    }

                    _sb.AppendLine("} block_in[];" + Environment.NewLine);
                }
            }
            else
            {
                PrintDeclAttributes(_decl.InAttributes.Values, "in");
            }
        }

        private void PrintDeclOutAttributes()
        {
            if (_decl.ShaderType == GalShaderType.Fragment)
            {
                int count = 0;

                for (int attachment = 0; attachment < 8; attachment++)
                {
                    if (_header.OmapTargets[attachment].Enabled)
                    {
                        _sb.AppendLine("layout (location = " + attachment + ") out vec4 " + GlslDecl.FragmentOutputName + attachment + ";");

                        count++;
                    }
                }

                if (count > 0)
                {
                    _sb.AppendLine();
                }
            }
            else
            {
                _sb.AppendLine("layout (location = " + GlslDecl.PositionOutAttrLocation + ") out vec4 " + GlslDecl.PositionOutAttrName + ";");
                _sb.AppendLine();
            }

            PrintDeclAttributes(_decl.OutAttributes.Values, "out");
        }

        private void PrintDeclAttributes(IEnumerable<ShaderDeclInfo> decls, string inOut)
        {
            int count = 0;

            foreach (ShaderDeclInfo declInfo in decls.OrderBy(DeclKeySelector))
            {
                if (declInfo.Index >= 0)
                {
                    _sb.AppendLine("layout (location = " + declInfo.Index + ") " + inOut + " vec4 " + declInfo.Name + ";");

                    count++;
                }
            }

            if (count > 0)
            {
                _sb.AppendLine();
            }
        }

        private void PrintDeclGprs()
        {
            PrintDecls(_decl.Gprs);
            PrintDecls(_decl.GprsHalf);
        }

        private void PrintDeclPreds()
        {
            PrintDecls(_decl.Preds, "bool");
        }

        private void PrintDeclSsy()
        {
            _sb.AppendLine("uint " + GlslDecl.SsyCursorName + " = 0;");

            _sb.AppendLine("uint " + GlslDecl.SsyStackName + "[" + GlslDecl.SsyStackSize + "];" + Environment.NewLine);
        }

        private void PrintDecls(IReadOnlyDictionary<int, ShaderDeclInfo> dict, string customType = null, string suffix = "")
        {
            foreach (ShaderDeclInfo declInfo in dict.Values.OrderBy(DeclKeySelector))
            {
                string name;

                if (customType != null)
                {
                    name = customType + " " + declInfo.Name + suffix + ";";
                }
                else if (declInfo.Name.Contains(GlslDecl.FragmentOutputName))
                {
                    name = "layout (location = " + declInfo.Index / 4 + ") out vec4 " + declInfo.Name + suffix + ";";
                }
                else
                {
                    name = GetDecl(declInfo) + suffix + ";";
                }

                _sb.AppendLine(name);
            }

            if (dict.Count > 0)
            {
                _sb.AppendLine();
            }
        }

        private int DeclKeySelector(ShaderDeclInfo declInfo)
        {
            return declInfo.Cbuf << 24 | declInfo.Index;
        }

        private string GetDecl(ShaderDeclInfo declInfo)
        {
            if (declInfo.Size == 4)
            {
                return "vec4 " + declInfo.Name;
            }
            else
            {
                return "float " + declInfo.Name;
            }
        }

        private void PrintMain()
        {
            _sb.AppendLine("void main() {");

            foreach (KeyValuePair<int, ShaderDeclInfo> kv in _decl.InAttributes)
            {
                if (!_decl.Attributes.TryGetValue(kv.Key, out ShaderDeclInfo attr))
                {
                    continue;
                }

                ShaderDeclInfo declInfo = kv.Value;

                if (_decl.ShaderType == GalShaderType.Geometry)
                {
                    for (int vertex = 0; vertex < MaxVertexInput; vertex++)
                    {
                        string dst = attr.Name + "[" + vertex + "]";

                        string src = "block_in[" + vertex + "]." + declInfo.Name;

                        _sb.AppendLine(IdentationStr + dst + " = " + src + ";");
                    }
                }
                else
                {
                    _sb.AppendLine(IdentationStr + attr.Name + " = " + declInfo.Name + ";");
                }
            }

            _sb.AppendLine(IdentationStr + "uint pc;");

            if (_blocksB != null)
            {
                PrintProgram(_blocks,  GlslDecl.BasicBlockAName);
                PrintProgram(_blocksB, GlslDecl.BasicBlockBName);
            }
            else
            {
                PrintProgram(_blocks, GlslDecl.BasicBlockName);
            }

            if (_decl.ShaderType != GalShaderType.Geometry)
            {
                PrintAttrToOutput();
            }

            if (_decl.ShaderType == GalShaderType.Fragment)
            {
                if (_header.OmapDepth)
                {
                    _sb.AppendLine(IdentationStr + "gl_FragDepth = " + GlslDecl.GetGprName(_header.DepthRegister) + ";");
                }

                int gprIndex = 0;

                for (int attachment = 0; attachment < 8; attachment++)
                {
                    string output = GlslDecl.FragmentOutputName + attachment;

                    OmapTarget target = _header.OmapTargets[attachment];

                    for (int component = 0; component < 4; component++)
                    {
                        if (target.ComponentEnabled(component))
                        {
                            _sb.AppendLine(IdentationStr + output + "[" + component + "] = " + GlslDecl.GetGprName(gprIndex) + ";");

                            gprIndex++;
                        }
                    }
                }
            }

            _sb.AppendLine("}");
        }

        private void PrintProgram(ShaderIrBlock[] blocks, string name)
        {
            const string ident1 = IdentationStr;
            const string ident2 = ident1 + IdentationStr;
            const string ident3 = ident2 + IdentationStr;
            const string ident4 = ident3 + IdentationStr;

            _sb.AppendLine(ident1 + "pc = " + GetBlockPosition(blocks[0]) + ";");
            _sb.AppendLine(ident1 + "do {");
            _sb.AppendLine(ident2 + "switch (pc) {");

            foreach (ShaderIrBlock block in blocks)
            {
                string functionName = block.Position.ToString("x8");

                _sb.AppendLine(ident3 + "case 0x" + functionName + ": pc = " + name + "_" + functionName + "(); break;");
            }

            _sb.AppendLine(ident3 + "default:");
            _sb.AppendLine(ident4 + "pc = 0;");
            _sb.AppendLine(ident4 + "break;");

            _sb.AppendLine(ident2 + "}");
            _sb.AppendLine(ident1 + "} while (pc != 0);");
        }

        private void PrintAttrToOutput(string identation = IdentationStr)
        {
            foreach (KeyValuePair<int, ShaderDeclInfo> kv in _decl.OutAttributes)
            {
                if (!_decl.Attributes.TryGetValue(kv.Key, out ShaderDeclInfo attr))
                {
                    continue;
                }

                ShaderDeclInfo declInfo = kv.Value;

                string name = attr.Name;

                if (_decl.ShaderType == GalShaderType.Geometry)
                {
                    name += "[0]";
                }

                _sb.AppendLine(identation + declInfo.Name + " = " + name + ";");
            }

            if (_decl.ShaderType == GalShaderType.Vertex)
            {
                _sb.AppendLine(identation + "gl_Position.xy *= " + GlslDecl.FlipUniformName + ";");
            }

            if (_decl.ShaderType != GalShaderType.Fragment)
            {
                _sb.AppendLine(identation + GlslDecl.PositionOutAttrName + " = gl_Position;");
                _sb.AppendLine(identation + GlslDecl.PositionOutAttrName + ".w = 1;");
            }
        }

        private void PrintBlockScope(ShaderIrBlock[] blocks, string name)
        {
            foreach (ShaderIrBlock block in blocks)
            {
                _sb.AppendLine("uint " + name + "_" + block.Position.ToString("x8") + "() {");

                PrintNodes(block, block.GetNodes());

                _sb.AppendLine("}" + Environment.NewLine);
            }
        }

        private void PrintNodes(ShaderIrBlock block, ShaderIrNode[] nodes)
        {
            foreach (ShaderIrNode node in nodes)
            {
                PrintNode(block, node, IdentationStr);
            }

            if (nodes.Length == 0)
            {
                _sb.AppendLine(IdentationStr + "return 0u;");

                return;
            }

            ShaderIrNode last = nodes[nodes.Length - 1];

            bool unconditionalFlowChange = false;

            if (last is ShaderIrOp op)
            {
                switch (op.Inst)
                {
                    case ShaderIrInst.Bra:
                    case ShaderIrInst.Exit:
                    case ShaderIrInst.Sync:
                        unconditionalFlowChange = true;
                        break;
                }
            }

            if (!unconditionalFlowChange)
            {
                if (block.Next != null)
                {
                    _sb.AppendLine(IdentationStr + "return " + GetBlockPosition(block.Next) + ";");
                }
                else
                {
                    _sb.AppendLine(IdentationStr + "return 0u;");
                }
            }
        }

        private void PrintNode(ShaderIrBlock block, ShaderIrNode node, string identation)
        {
            if (node is ShaderIrCond cond)
            {
                string ifExpr = GetSrcExpr(cond.Pred, true);

                if (cond.Not)
                {
                    ifExpr = "!(" + ifExpr + ")";
                }

                _sb.AppendLine(identation + "if (" + ifExpr + ") {");

                PrintNode(block, cond.Child, identation + IdentationStr);

                _sb.AppendLine(identation + "}");
            }
            else if (node is ShaderIrAsg asg)
            {
                if (IsValidOutOper(asg.Dst))
                {
                    string expr = GetSrcExpr(asg.Src, true);

                    expr = GetExprWithCast(asg.Dst, asg.Src, expr);

                    _sb.AppendLine(identation + GetDstOperName(asg.Dst) + " = " + expr + ";");
                }
            }
            else if (node is ShaderIrOp op)
            {
                switch (op.Inst)
                {
                    case ShaderIrInst.Bra:
                    {
                        _sb.AppendLine(identation + "return " + GetBlockPosition(block.Branch) + ";");

                        break;
                    }

                    case ShaderIrInst.Emit:
                    {
                        PrintAttrToOutput(identation);

                        _sb.AppendLine(identation + "EmitVertex();");

                        break;
                    }

                    case ShaderIrInst.Ssy:
                    {
                        string stackIndex = GlslDecl.SsyStackName + "[" + GlslDecl.SsyCursorName + "]";

                        int targetPosition = (op.OperandA as ShaderIrOperImm).Value;

                        string target = "0x" + targetPosition.ToString("x8") + "u";

                        _sb.AppendLine(identation + stackIndex + " = " + target + ";");

                        _sb.AppendLine(identation + GlslDecl.SsyCursorName + "++;");

                        break;
                    }

                    case ShaderIrInst.Sync:
                    {
                        _sb.AppendLine(identation + GlslDecl.SsyCursorName + "--;");

                        string target = GlslDecl.SsyStackName + "[" + GlslDecl.SsyCursorName + "]";

                        _sb.AppendLine(identation + "return " + target + ";");

                        break;
                    }

                    default:
                        _sb.AppendLine(identation + GetSrcExpr(op, true) + ";");

                        break;
                }
            }
            else if (node is ShaderIrCmnt cmnt)
            {
                _sb.AppendLine(identation + "// " + cmnt.Comment);
            }
            else
            {
                throw new InvalidOperationException();
            }
        }

        private bool IsValidOutOper(ShaderIrNode node)
        {
            if (node is ShaderIrOperGpr gpr && gpr.IsConst)
            {
                return false;
            }
            else if (node is ShaderIrOperPred pred && pred.IsConst)
            {
                return false;
            }

            return true;
        }

        private string GetDstOperName(ShaderIrNode node)
        {
            if (node is ShaderIrOperAbuf abuf)
            {
                return GetOutAbufName(abuf);
            }
            else if (node is ShaderIrOperGpr gpr)
            {
                return GetName(gpr);
            }
            else if (node is ShaderIrOperPred pred)
            {
                return GetName(pred);
            }

            throw new ArgumentException(nameof(node));
        }

        private string GetSrcExpr(ShaderIrNode node, bool entry = false)
        {
            switch (node)
            {
                case ShaderIrOperAbuf abuf: return GetName (abuf);
                case ShaderIrOperCbuf cbuf: return GetName (cbuf);
                case ShaderIrOperGpr  gpr:  return GetName (gpr);
                case ShaderIrOperImm  imm:  return GetValue(imm);
                case ShaderIrOperImmf immf: return GetValue(immf);
                case ShaderIrOperPred pred: return GetName (pred);

                case ShaderIrOp op:
                    string expr;

                    if (_instsExpr.TryGetValue(op.Inst, out GetInstExpr getExpr))
                    {
                        expr = getExpr(op);
                    }
                    else
                    {
                        throw new NotImplementedException(op.Inst.ToString());
                    }

                    if (!entry && NeedsParentheses(op))
                    {
                        expr = "(" + expr + ")";
                    }

                    return expr;

                default: throw new ArgumentException(nameof(node));
            }
        }

        private static bool NeedsParentheses(ShaderIrOp op)
        {
            switch (op.Inst)
            {
                case ShaderIrInst.Ipa:
                case ShaderIrInst.Texq:
                case ShaderIrInst.Texs:
                case ShaderIrInst.Tld4:
                case ShaderIrInst.Txlf:
                    return false;
            }

            return true;
        }

        private string GetName(ShaderIrOperCbuf cbuf)
        {
            if (!_decl.Uniforms.TryGetValue(cbuf.Index, out ShaderDeclInfo declInfo))
            {
                throw new InvalidOperationException();
            }

            if (cbuf.Offs != null)
            {
                string offset = "floatBitsToInt(" + GetSrcExpr(cbuf.Offs) + ")";

                string index = "(" + cbuf.Pos * 4 + " + " + offset + ")";

                return $"{declInfo.Name}_data[{index} / 16][({index} / 4) % 4]";
            }
            else
            {
                return $"{declInfo.Name}_data[{cbuf.Pos / 4}][{cbuf.Pos % 4}]";
            }
        }

        private string GetOutAbufName(ShaderIrOperAbuf abuf)
        {
            if (_decl.ShaderType == GalShaderType.Geometry)
            {
                switch (abuf.Offs)
                {
                    case GlslDecl.LayerAttr: return "gl_Layer";
                }
            }

            return GetAttrTempName(abuf);
        }

        private string GetName(ShaderIrOperAbuf abuf)
        {
            //Handle special scalar read-only attributes here.
            if (_decl.ShaderType == GalShaderType.Vertex)
            {
                switch (abuf.Offs)
                {
                    case GlslDecl.VertexIdAttr:   return "gl_VertexID";
                    case GlslDecl.InstanceIdAttr: return GlslDecl.InstanceUniformName;
                }
            }
            else if (_decl.ShaderType == GalShaderType.TessEvaluation)
            {
                switch (abuf.Offs)
                {
                    case GlslDecl.TessCoordAttrX: return "gl_TessCoord.x";
                    case GlslDecl.TessCoordAttrY: return "gl_TessCoord.y";
                    case GlslDecl.TessCoordAttrZ: return "gl_TessCoord.z";
                }
            }
            else if (_decl.ShaderType == GalShaderType.Fragment)
            {
                switch (abuf.Offs)
                {
                    case GlslDecl.PointCoordAttrX: return "gl_PointCoord.x";
                    case GlslDecl.PointCoordAttrY: return "gl_PointCoord.y";
                    case GlslDecl.FaceAttr:        return "(gl_FrontFacing ? -1 : 0)";
                }
            }

            return GetAttrTempName(abuf);
        }

        private string GetAttrTempName(ShaderIrOperAbuf abuf)
        {
            int index =  abuf.Offs >> 4;
            int elem  = (abuf.Offs >> 2) & 3;

            string swizzle = "." + GetAttrSwizzle(elem);

            if (!_decl.Attributes.TryGetValue(index, out ShaderDeclInfo declInfo))
            {
                //Handle special vec4 attributes here
                //(for example, index 7 is always gl_Position).
                if (index == GlslDecl.GlPositionVec4Index)
                {
                    string name =
                        _decl.ShaderType != GalShaderType.Vertex &&
                        _decl.ShaderType != GalShaderType.Geometry ? GlslDecl.PositionOutAttrName : "gl_Position";

                    return name + swizzle;
                }
                else if (abuf.Offs == GlslDecl.PointSizeAttr)
                {
                    return "gl_PointSize";
                }
            }

            if (declInfo.Index >= 32)
            {
                throw new InvalidOperationException($"Shader attribute offset {abuf.Offs} is invalid.");
            }

            if (_decl.ShaderType == GalShaderType.Geometry)
            {
                string vertex = "floatBitsToInt(" + GetSrcExpr(abuf.Vertex) + ")";

                return declInfo.Name + "[" + vertex + "]" + swizzle;
            }
            else
            {
                return declInfo.Name + swizzle;
            }
        }

        private string GetName(ShaderIrOperGpr gpr)
        {
            if (gpr.IsConst)
            {
                return "0";
            }

            if (gpr.RegisterSize == ShaderRegisterSize.Single)
            {
                return GetNameWithSwizzle(_decl.Gprs, gpr.Index);
            }
            else if (gpr.RegisterSize == ShaderRegisterSize.Half)
            {
                return GetNameWithSwizzle(_decl.GprsHalf, (gpr.Index << 1) | gpr.HalfPart);
            }
            else /* if (Gpr.RegisterSize == ShaderRegisterSize.Double) */
            {
                throw new NotImplementedException("Double types are not supported.");
            }
        }

        private string GetValue(ShaderIrOperImm imm)
        {
            //Only use hex is the value is too big and would likely be hard to read as int.
            if (imm.Value >  0xfff ||
                imm.Value < -0xfff)
            {
                return "0x" + imm.Value.ToString("x8", CultureInfo.InvariantCulture);
            }
            else
            {
                return GetIntConst(imm.Value);
            }
        }

        private string GetValue(ShaderIrOperImmf immf)
        {
            return GetFloatConst(immf.Value);
        }

        private string GetName(ShaderIrOperPred pred)
        {
            return pred.IsConst ? "true" : GetNameWithSwizzle(_decl.Preds, pred.Index);
        }

        private string GetNameWithSwizzle(IReadOnlyDictionary<int, ShaderDeclInfo> dict, int index)
        {
            int vecIndex = index & ~3;

            if (dict.TryGetValue(vecIndex, out ShaderDeclInfo declInfo))
            {
                if (declInfo.Size > 1 && index < vecIndex + declInfo.Size)
                {
                    return declInfo.Name + "." + GetAttrSwizzle(index & 3);
                }
            }

            if (!dict.TryGetValue(index, out declInfo))
            {
                throw new InvalidOperationException();
            }

            return declInfo.Name;
        }

        private string GetAttrSwizzle(int elem)
        {
            return "xyzw".Substring(elem, 1);
        }

        private string GetAbsExpr(ShaderIrOp op) => GetUnaryCall(op, "abs");

        private string GetAddExpr(ShaderIrOp op) => GetBinaryExpr(op, "+");

        private string GetAndExpr(ShaderIrOp op) => GetBinaryExpr(op, "&");

        private string GetAsrExpr(ShaderIrOp op) => GetBinaryExpr(op, ">>");

        private string GetBandExpr(ShaderIrOp op) => GetBinaryExpr(op, "&&");

        private string GetBnotExpr(ShaderIrOp op) => GetUnaryExpr(op, "!");

        private string GetBorExpr(ShaderIrOp op) => GetBinaryExpr(op, "||");

        private string GetBxorExpr(ShaderIrOp op) => GetBinaryExpr(op, "^^");

        private string GetCeilExpr(ShaderIrOp op) => GetUnaryCall(op, "ceil");

        private string GetClampsExpr(ShaderIrOp op)
        {
            return "clamp(" + GetOperExpr(op, op.OperandA) + ", " +
                              GetOperExpr(op, op.OperandB) + ", " +
                              GetOperExpr(op, op.OperandC) + ")";
        }

        private string GetClampuExpr(ShaderIrOp op)
        {
            return "int(clamp(uint(" + GetOperExpr(op, op.OperandA) + "), " +
                             "uint(" + GetOperExpr(op, op.OperandB) + "), " +
                             "uint(" + GetOperExpr(op, op.OperandC) + ")))";
        }

        private string GetCeqExpr(ShaderIrOp op) => GetBinaryExpr(op, "==");

        private string GetCequExpr(ShaderIrOp op) => GetBinaryExprWithNaN(op, "==");

        private string GetCgeExpr(ShaderIrOp op) => GetBinaryExpr(op, ">=");

        private string GetCgeuExpr(ShaderIrOp op) => GetBinaryExprWithNaN(op, ">=");

        private string GetCgtExpr(ShaderIrOp op) => GetBinaryExpr(op, ">");

        private string GetCgtuExpr(ShaderIrOp op) => GetBinaryExprWithNaN(op, ">");

        private string GetCleExpr(ShaderIrOp op) => GetBinaryExpr(op, "<=");

        private string GetCleuExpr(ShaderIrOp op) => GetBinaryExprWithNaN(op, "<=");

        private string GetCltExpr(ShaderIrOp op) => GetBinaryExpr(op, "<");

        private string GetCltuExpr(ShaderIrOp op) => GetBinaryExprWithNaN(op, "<");

        private string GetCnanExpr(ShaderIrOp op) => GetUnaryCall(op, "isnan");

        private string GetCneExpr(ShaderIrOp op) => GetBinaryExpr(op, "!=");

        private string GetCutExpr(ShaderIrOp op) => "EndPrimitive()";

        private string GetCneuExpr(ShaderIrOp op) => GetBinaryExprWithNaN(op, "!=");

        private string GetCnumExpr(ShaderIrOp op) => GetUnaryCall(op, "!isnan");

        private string GetExitExpr(ShaderIrOp op) => "return 0u";

        private string GetFcosExpr(ShaderIrOp op) => GetUnaryCall(op, "cos");

        private string GetFex2Expr(ShaderIrOp op) => GetUnaryCall(op, "exp2");

        private string GetFfmaExpr(ShaderIrOp op) => GetTernaryExpr(op, "*", "+");

        private string GetFclampExpr(ShaderIrOp op) => GetTernaryCall(op, "clamp");

        private string GetFlg2Expr(ShaderIrOp op) => GetUnaryCall(op, "log2");

        private string GetFloorExpr(ShaderIrOp op) => GetUnaryCall(op, "floor");

        private string GetFrcpExpr(ShaderIrOp op) => GetUnaryExpr(op, "1 / ");

        private string GetFrsqExpr(ShaderIrOp op) => GetUnaryCall(op, "inversesqrt");

        private string GetFsinExpr(ShaderIrOp op) => GetUnaryCall(op, "sin");

        private string GetFsqrtExpr(ShaderIrOp op) => GetUnaryCall(op, "sqrt");

        private string GetFtosExpr(ShaderIrOp op)
        {
            return "int(" + GetOperExpr(op, op.OperandA) + ")";
        }

        private string GetFtouExpr(ShaderIrOp op)
        {
            return "int(uint(" + GetOperExpr(op, op.OperandA) + "))";
        }

        private string GetIpaExpr(ShaderIrOp op)
        {
            ShaderIrMetaIpa meta = (ShaderIrMetaIpa)op.MetaData;

            ShaderIrOperAbuf abuf = (ShaderIrOperAbuf)op.OperandA;

            if (meta.Mode == ShaderIpaMode.Pass)
            {
                int index = abuf.Offs >> 4;
                int elem = (abuf.Offs >> 2) & 3;

                if (_decl.ShaderType == GalShaderType.Fragment && index == GlslDecl.GlPositionVec4Index)
                {
                    switch (elem)
                    {
                        case 0: return "gl_FragCoord.x";
                        case 1: return "gl_FragCoord.y";
                        case 2: return "gl_FragCoord.z";
                        case 3: return "1";
                    }
                }
            }

            return GetSrcExpr(op.OperandA);
        }

        private string GetKilExpr(ShaderIrOp op) => "discard";

        private string GetLslExpr(ShaderIrOp op) => GetBinaryExpr(op, "<<");
        private string GetLsrExpr(ShaderIrOp op)
        {
            return "int(uint(" + GetOperExpr(op, op.OperandA) + ") >> " +
                                 GetOperExpr(op, op.OperandB) + ")";
        }

        private string GetMaxExpr(ShaderIrOp op) => GetBinaryCall(op, "max");
        private string GetMinExpr(ShaderIrOp op) => GetBinaryCall(op, "min");

        private string GetMulExpr(ShaderIrOp op) => GetBinaryExpr(op, "*");

        private string GetNegExpr(ShaderIrOp op) => GetUnaryExpr(op, "-");

        private string GetNotExpr(ShaderIrOp op) => GetUnaryExpr(op, "~");

        private string GetOrExpr(ShaderIrOp op) => GetBinaryExpr(op, "|");

        private string GetStofExpr(ShaderIrOp op)
        {
            return "float(" + GetOperExpr(op, op.OperandA) + ")";
        }

        private string GetSubExpr(ShaderIrOp op) => GetBinaryExpr(op, "-");

        private string GetTexbExpr(ShaderIrOp op)
        {
            ShaderIrMetaTex meta = (ShaderIrMetaTex)op.MetaData;

            if (!_decl.CbTextures.TryGetValue(op, out ShaderDeclInfo declInfo))
            {
                throw new InvalidOperationException();
            }

            string coords = GetTexSamplerCoords(op);

            string ch = "rgba".Substring(meta.Elem, 1);

            return GetTextureOperation(op, declInfo.Name, coords, ch);
        }

        private string GetTexqExpr(ShaderIrOp op)
        {
            ShaderIrMetaTexq meta = (ShaderIrMetaTexq)op.MetaData;

            string ch = "xyzw".Substring(meta.Elem, 1);

            if (meta.Info == ShaderTexqInfo.Dimension)
            {
                string sampler = GetTexSamplerName(op);

                string lod = GetOperExpr(op, op.OperandA); //???

                return "textureSize(" + sampler + ", " + lod + ")." + ch;
            }
            else
            {
                throw new NotImplementedException(meta.Info.ToString());
            }
        }

        private string GetTexsExpr(ShaderIrOp op)
        {
            ShaderIrMetaTex meta = (ShaderIrMetaTex)op.MetaData;

            string sampler = GetTexSamplerName(op);

            string coords = GetTexSamplerCoords(op);

            string ch = "rgba".Substring(meta.Elem, 1);

            return GetTextureOperation(op, sampler, coords, ch);
        }

        private string GetTld4Expr(ShaderIrOp op)
        {
            ShaderIrMetaTex meta = (ShaderIrMetaTex)op.MetaData;

            string sampler = GetTexSamplerName(op);

            string coords = GetTexSamplerCoords(op);

            string ch = "rgba".Substring(meta.Elem, 1);

            return GetTextureGatherOperation(op, sampler, coords, ch);
        }

        // TODO: support AOFFI on non nvidia drivers
        private string GetTxlfExpr(ShaderIrOp op)
        {
            // TODO: Support all suffixes
            ShaderIrMetaTex meta = (ShaderIrMetaTex)op.MetaData;

            TextureInstructionSuffix suffix = meta.TextureInstructionSuffix;

            string sampler = GetTexSamplerName(op);

            string coords = GetITexSamplerCoords(op);

            string ch = "rgba".Substring(meta.Elem, 1);

            string lod = "0";

            if (meta.LevelOfDetail != null)
            {
                lod = GetOperExpr(op, meta.LevelOfDetail);
            }

            if ((suffix & TextureInstructionSuffix.AOffI) != 0 && _isNvidiaDriver)
            {
                string offset = GetTextureOffset(meta, GetOperExpr(op, meta.Offset));
                return "texelFetchOffset(" + sampler + ", " + coords + ", " + lod + ", " + offset + ")." + ch;
            }

            return "texelFetch(" + sampler + ", " + coords + ", " + lod + ")." + ch;
        }

        private string GetTruncExpr(ShaderIrOp op) => GetUnaryCall(op, "trunc");

        private string GetUtofExpr(ShaderIrOp op)
        {
            return "float(uint(" + GetOperExpr(op, op.OperandA) + "))";
        }

        private string GetXorExpr(ShaderIrOp op) => GetBinaryExpr(op, "^");

        private string GetUnaryCall(ShaderIrOp op, string funcName)
        {
            return funcName + "(" + GetOperExpr(op, op.OperandA) + ")";
        }

        private string GetBinaryCall(ShaderIrOp op, string funcName)
        {
            return funcName + "(" + GetOperExpr(op, op.OperandA) + ", " +
                                    GetOperExpr(op, op.OperandB) + ")";
        }

        private string GetTernaryCall(ShaderIrOp op, string funcName)
        {
            return funcName + "(" + GetOperExpr(op, op.OperandA) + ", " +
                                    GetOperExpr(op, op.OperandB) + ", " +
                                    GetOperExpr(op, op.OperandC) + ")";
        }

        private string GetUnaryExpr(ShaderIrOp op, string opr)
        {
            return opr + GetOperExpr(op, op.OperandA);
        }

        private string GetBinaryExpr(ShaderIrOp op, string opr)
        {
            return GetOperExpr(op, op.OperandA) + " " + opr + " " +
                   GetOperExpr(op, op.OperandB);
        }

        private string GetBinaryExprWithNaN(ShaderIrOp op, string opr)
        {
            string a = GetOperExpr(op, op.OperandA);
            string b = GetOperExpr(op, op.OperandB);

            string nanCheck =
                " || isnan(" + a + ")" +
                " || isnan(" + b + ")";

            return a + " " + opr + " " + b + nanCheck;
        }

        private string GetTernaryExpr(ShaderIrOp op, string opr1, string opr2)
        {
            return GetOperExpr(op, op.OperandA) + " " + opr1 + " " +
                   GetOperExpr(op, op.OperandB) + " " + opr2 + " " +
                   GetOperExpr(op, op.OperandC);
        }

        private string GetTexSamplerName(ShaderIrOp op)
        {
            ShaderIrOperImm node = (ShaderIrOperImm)op.OperandC;

            int handle = ((ShaderIrOperImm)op.OperandC).Value;

            if (!_decl.Textures.TryGetValue(handle, out ShaderDeclInfo declInfo))
            {
                throw new InvalidOperationException();
            }

            return declInfo.Name;
        }

        private string GetTexSamplerCoords(ShaderIrOp op)
        {
            ShaderIrMetaTex meta = (ShaderIrMetaTex)op.MetaData;

            bool hasDepth = (meta.TextureInstructionSuffix & TextureInstructionSuffix.Dc) != 0;

            int coords = ImageUtils.GetCoordsCountTextureTarget(meta.TextureTarget);

            bool isArray = ImageUtils.IsArray(meta.TextureTarget);


            string GetLastArgument(ShaderIrNode node)
            {
                string result = GetOperExpr(op, node);

                // array index is actually an integer so we need to pass it correctly
                if (isArray)
                {
                    result = "float(floatBitsToInt(" + result + "))";
                }

                return result;
            }

            string lastArgument;
            string depthArgument = "";

            int vecSize = coords;
            if (hasDepth && op.Inst != ShaderIrInst.Tld4)
            {
                vecSize++;
                depthArgument = $", {GetOperExpr(op, meta.DepthCompare)}";
            }

            switch (coords)
            {
                case 1:
                    if (hasDepth)
                    {
                        return $"vec3({GetOperExpr(op, meta.Coordinates[0])}, 0.0{depthArgument})";
                    }

                    return GetOperExpr(op, meta.Coordinates[0]);
                case 2:
                    lastArgument = GetLastArgument(meta.Coordinates[1]);

                    return $"vec{vecSize}({GetOperExpr(op, meta.Coordinates[0])}, {lastArgument}{depthArgument})";
                case 3:
                    lastArgument = GetLastArgument(meta.Coordinates[2]);

                    return $"vec{vecSize}({GetOperExpr(op, meta.Coordinates[0])}, {GetOperExpr(op, meta.Coordinates[1])}, {lastArgument}{depthArgument})";
                case 4:
                    lastArgument = GetLastArgument(meta.Coordinates[3]);

                    return $"vec4({GetOperExpr(op, meta.Coordinates[0])}, {GetOperExpr(op, meta.Coordinates[1])}, {GetOperExpr(op, meta.Coordinates[2])}, {lastArgument}){depthArgument}";
                default:
                    throw new InvalidOperationException();
            }

        }

        private string GetTextureOffset(ShaderIrMetaTex meta, string oper, int shift = 4, int mask = 0xF)
        {
            string GetOffset(string operation, int index)
            {
                return $"({operation} >> {index * shift}) & 0x{mask:x}";
            }

            int coords = ImageUtils.GetCoordsCountTextureTarget(meta.TextureTarget);

            if (ImageUtils.IsArray(meta.TextureTarget))
                coords -= 1;

            switch (coords)
            {
                case 1:
                    return GetOffset(oper, 0);
                case 2:
                    return "ivec2(" + GetOffset(oper, 0) + ", " + GetOffset(oper, 1) + ")";
                case 3:
                    return "ivec3(" + GetOffset(oper, 0) + ", " + GetOffset(oper, 1) + ", " + GetOffset(oper, 2) + ")";
                case 4:
                    return "ivec4(" + GetOffset(oper, 0) + ", " + GetOffset(oper, 1) + ", " + GetOffset(oper, 2) + ", " + GetOffset(oper, 3) + ")";
                default:
                    throw new InvalidOperationException();
            }
        }

        // TODO: support AOFFI on non nvidia drivers
        private string GetTextureGatherOperation(ShaderIrOp op, string sampler, string coords, string ch)
        {
            ShaderIrMetaTex meta = (ShaderIrMetaTex)op.MetaData;

            TextureInstructionSuffix suffix = meta.TextureInstructionSuffix;

            string chString = "." + ch;

            string comp = meta.Component.ToString();

            if ((suffix & TextureInstructionSuffix.Dc) != 0)
            {
                comp = GetOperExpr(op, meta.DepthCompare);
            }

            if ((suffix & TextureInstructionSuffix.AOffI) != 0 && _isNvidiaDriver)
            {
                string offset = GetTextureOffset(meta, "floatBitsToInt((" + GetOperExpr(op, meta.Offset) + "))", 8, 0x3F);

                if ((suffix & TextureInstructionSuffix.Dc) != 0)
                {
                    return "textureGatherOffset(" + sampler + ", " + coords + ", " + comp + ", " + offset + ")" + chString;
                }

                return "textureGatherOffset(" + sampler + ", " + coords + ", " + offset + ", " + comp + ")" + chString;
            }
            // TODO: Support PTP
            else if ((suffix & TextureInstructionSuffix.Ptp) != 0)
            {
                throw new NotImplementedException();
            }

            return "textureGather(" + sampler + ", " + coords + ", " + comp + ")" + chString;
        }

        // TODO: support AOFFI on non nvidia drivers
        private string GetTextureOperation(ShaderIrOp op, string sampler, string coords, string ch)
        {
            ShaderIrMetaTex meta = (ShaderIrMetaTex)op.MetaData;

            TextureInstructionSuffix suffix = meta.TextureInstructionSuffix;

            string chString = "." + ch;

            if ((suffix & TextureInstructionSuffix.Dc) != 0)
            {
                chString = "";
            }

            // TODO: Support LBA and LLA
            if ((suffix & TextureInstructionSuffix.Lz) != 0)
            {
                if ((suffix & TextureInstructionSuffix.AOffI) != 0 && _isNvidiaDriver)
                {
                    string offset = GetTextureOffset(meta, "floatBitsToInt((" + GetOperExpr(op, meta.Offset) + "))");

                    return "textureLodOffset(" + sampler + ", " + coords + ", 0.0, " + offset + ")" + chString;
                }

                return "textureLod(" + sampler + ", " + coords + ", 0.0)" + chString;
            }
            else if ((suffix & TextureInstructionSuffix.Lb) != 0)
            {
                if ((suffix & TextureInstructionSuffix.AOffI) != 0 && _isNvidiaDriver)
                {
                    string offset = GetTextureOffset(meta, "floatBitsToInt((" + GetOperExpr(op, meta.Offset) + "))");

                    return "textureOffset(" + sampler + ", " + coords + ", " + offset + ", " + GetOperExpr(op, meta.LevelOfDetail) + ")" + chString;
                }

                return "texture(" + sampler + ", " + coords + ", " + GetOperExpr(op, meta.LevelOfDetail) + ")" + chString;
            }
            else if ((suffix & TextureInstructionSuffix.Ll) != 0)
            {
                if ((suffix & TextureInstructionSuffix.AOffI) != 0 && _isNvidiaDriver)
                {
                    string offset = GetTextureOffset(meta, "floatBitsToInt((" + GetOperExpr(op, meta.Offset) + "))");

                    return "textureLodOffset(" + sampler + ", " + coords + ", " + GetOperExpr(op, meta.LevelOfDetail) + ", " + offset + ")" + chString;
                }

                return "textureLod(" + sampler + ", " + coords + ", " + GetOperExpr(op, meta.LevelOfDetail) + ")" + chString;
            }
            else if ((suffix & TextureInstructionSuffix.AOffI) != 0 && _isNvidiaDriver)
            {
                string offset = GetTextureOffset(meta, "floatBitsToInt((" + GetOperExpr(op, meta.Offset) + "))");

                return "textureOffset(" + sampler + ", " + coords + ", " + offset + ")" + chString;
            }
            else
            {
                return "texture(" + sampler + ", " + coords + ")" + chString;
            }
            throw new NotImplementedException($"Texture Suffix {meta.TextureInstructionSuffix} is not implemented");

        }

        private string GetITexSamplerCoords(ShaderIrOp op)
        {
            ShaderIrMetaTex meta = (ShaderIrMetaTex)op.MetaData;

            switch (ImageUtils.GetCoordsCountTextureTarget(meta.TextureTarget))
            {
                case 1:
                    return GetOperExpr(op, meta.Coordinates[0]);
                case 2:
                    return "ivec2(" + GetOperExpr(op, meta.Coordinates[0]) + ", " + GetOperExpr(op, meta.Coordinates[1]) + ")";
                case 3:
                    return "ivec3(" + GetOperExpr(op, meta.Coordinates[0]) + ", " + GetOperExpr(op, meta.Coordinates[1]) + ", " + GetOperExpr(op, meta.Coordinates[2]) + ")";
                default:
                    throw new InvalidOperationException();
            }
        }

        private string GetOperExpr(ShaderIrOp op, ShaderIrNode oper)
        {
            return GetExprWithCast(op, oper, GetSrcExpr(oper));
        }

        private static string GetExprWithCast(ShaderIrNode dst, ShaderIrNode src, string expr)
        {
            //Note: The "DstType" (of the cast) is the type that the operation
            //uses on the source operands, while the "SrcType" is the destination
            //type of the operand result (if it is a operation) or just the type
            //of the variable for registers/uniforms/attributes.
            OperType dstType = GetSrcNodeType(dst);
            OperType srcType = GetDstNodeType(src);

            if (dstType != srcType)
            {
                //Check for invalid casts
                //(like bool to int/float and others).
                if (srcType != OperType.F32 &&
                    srcType != OperType.I32)
                {
                    throw new InvalidOperationException();
                }

                switch (src)
                {
                    case ShaderIrOperGpr gpr:
                    {
                        //When the Gpr is ZR, just return the 0 value directly,
                        //since the float encoding for 0 is 0.
                        if (gpr.IsConst)
                        {
                            return "0";
                        }
                        break;
                    }
                }

                switch (dstType)
                {
                    case OperType.F32: expr = "intBitsToFloat(" + expr + ")"; break;
                    case OperType.I32: expr = "floatBitsToInt(" + expr + ")"; break;
                }
            }

            return expr;
        }

        private static string GetIntConst(int value)
        {
            string expr = value.ToString(CultureInfo.InvariantCulture);

            return value < 0 ? "(" + expr + ")" : expr;
        }

        private static string GetFloatConst(float value)
        {
            string expr = value.ToString(CultureInfo.InvariantCulture);

            return value < 0 ? "(" + expr + ")" : expr;
        }

        private static OperType GetDstNodeType(ShaderIrNode node)
        {
            //Special case instructions with the result type different
            //from the input types (like integer <-> float conversion) here.
            if (node is ShaderIrOp op)
            {
                switch (op.Inst)
                {
                    case ShaderIrInst.Stof:
                    case ShaderIrInst.Txlf:
                    case ShaderIrInst.Utof:
                        return OperType.F32;

                    case ShaderIrInst.Ftos:
                    case ShaderIrInst.Ftou:
                        return OperType.I32;
                }
            }

            return GetSrcNodeType(node);
        }

        private static OperType GetSrcNodeType(ShaderIrNode node)
        {
            switch (node)
            {
                case ShaderIrOperAbuf abuf:
                    return abuf.Offs == GlslDecl.LayerAttr      ||
                           abuf.Offs == GlslDecl.InstanceIdAttr ||
                           abuf.Offs == GlslDecl.VertexIdAttr   ||
                           abuf.Offs == GlslDecl.FaceAttr
                        ? OperType.I32
                        : OperType.F32;

                case ShaderIrOperCbuf cbuf: return OperType.F32;
                case ShaderIrOperGpr  gpr:  return OperType.F32;
                case ShaderIrOperImm  imm:  return OperType.I32;
                case ShaderIrOperImmf immf: return OperType.F32;
                case ShaderIrOperPred pred: return OperType.Bool;

                case ShaderIrOp op:
                    if (op.Inst > ShaderIrInst.B_Start &&
                        op.Inst < ShaderIrInst.B_End)
                    {
                        return OperType.Bool;
                    }
                    else if (op.Inst > ShaderIrInst.F_Start &&
                             op.Inst < ShaderIrInst.F_End)
                    {
                        return OperType.F32;
                    }
                    else if (op.Inst > ShaderIrInst.I_Start &&
                             op.Inst < ShaderIrInst.I_End)
                    {
                        return OperType.I32;
                    }
                    break;
            }

            throw new ArgumentException(nameof(node));
        }

        private static string GetBlockPosition(ShaderIrBlock block)
        {
            if (block != null)
            {
                return "0x" + block.Position.ToString("x8") + "u";
            }
            else
            {
                return "0u";
            }
        }
    }
}