Move solution and projects to src

10 files changed, 0 insertions, 4503 deletions

diff --git a/Ryujinx.Graphics.Shader/CodeGen/Spirv/CodeGenContext.cs b/Ryujinx.Graphics.Shader/CodeGen/Spirv/CodeGenContext.cs
deleted file mode 100644
index ed292ef1..00000000
--- a/Ryujinx.Graphics.Shader/CodeGen/Spirv/CodeGenContext.cs
+++ /dev/null
@@ -1,409 +0,0 @@
-using Ryujinx.Graphics.Shader.StructuredIr;
-using Ryujinx.Graphics.Shader.Translation;
-using Spv.Generator;
-using System;
-using System.Collections.Generic;
-using static Spv.Specification;
-
-namespace Ryujinx.Graphics.Shader.CodeGen.Spirv
-{
-    using IrConsts = IntermediateRepresentation.IrConsts;
-    using IrOperandType = IntermediateRepresentation.OperandType;
-
-    partial class CodeGenContext : Module
-    {
-        private const uint SpirvVersionMajor = 1;
-        private const uint SpirvVersionMinor = 3;
-        private const uint SpirvVersionRevision = 0;
-        private const uint SpirvVersionPacked = (SpirvVersionMajor << 16) | (SpirvVersionMinor << 8) | SpirvVersionRevision;
-
-        public StructuredProgramInfo Info { get; }
-
-        public ShaderConfig Config { get; }
-
-        public int InputVertices { get; }
-
-        public Dictionary<int, Instruction> UniformBuffers { get; } = new Dictionary<int, Instruction>();
-        public Instruction SupportBuffer { get; set; }
-        public Instruction UniformBuffersArray { get; set; }
-        public Instruction StorageBuffersArray { get; set; }
-        public Instruction LocalMemory { get; set; }
-        public Instruction SharedMemory { get; set; }
-        public Dictionary<TextureMeta, SamplerType> SamplersTypes { get; } = new Dictionary<TextureMeta, SamplerType>();
-        public Dictionary<TextureMeta, (Instruction, Instruction, Instruction)> Samplers { get; } = new Dictionary<TextureMeta, (Instruction, Instruction, Instruction)>();
-        public Dictionary<TextureMeta, (Instruction, Instruction)> Images { get; } = new Dictionary<TextureMeta, (Instruction, Instruction)>();
-        public Dictionary<IoDefinition, Instruction> Inputs { get; } = new Dictionary<IoDefinition, Instruction>();
-        public Dictionary<IoDefinition, Instruction> Outputs { get; } = new Dictionary<IoDefinition, Instruction>();
-        public Dictionary<IoDefinition, Instruction> InputsPerPatch { get; } = new Dictionary<IoDefinition, Instruction>();
-        public Dictionary<IoDefinition, Instruction> OutputsPerPatch { get; } = new Dictionary<IoDefinition, Instruction>();
-
-        public Instruction CoordTemp { get; set; }
-        private readonly Dictionary<AstOperand, Instruction> _locals = new Dictionary<AstOperand, Instruction>();
-        private readonly Dictionary<int, Instruction[]> _localForArgs = new Dictionary<int, Instruction[]>();
-        private readonly Dictionary<int, Instruction> _funcArgs = new Dictionary<int, Instruction>();
-        private readonly Dictionary<int, (StructuredFunction, Instruction)> _functions = new Dictionary<int, (StructuredFunction, Instruction)>();
-
-        private class BlockState
-        {
-            private int _entryCount;
-            private readonly List<Instruction> _labels = new List<Instruction>();
-
-            public Instruction GetNextLabel(CodeGenContext context)
-            {
-                return GetLabel(context, _entryCount);
-            }
-
-            public Instruction GetNextLabelAutoIncrement(CodeGenContext context)
-            {
-                return GetLabel(context, _entryCount++);
-            }
-
-            public Instruction GetLabel(CodeGenContext context, int index)
-            {
-                while (index >= _labels.Count)
-                {
-                    _labels.Add(context.Label());
-                }
-
-                return _labels[index];
-            }
-        }
-
-        private readonly Dictionary<AstBlock, BlockState> _labels = new Dictionary<AstBlock, BlockState>();
-
-        public Dictionary<AstBlock, (Instruction, Instruction)> LoopTargets { get; set; }
-
-        public AstBlock CurrentBlock { get; private set; }
-
-        public SpirvDelegates Delegates { get; }
-
-        public CodeGenContext(
-            StructuredProgramInfo info,
-            ShaderConfig config,
-            GeneratorPool<Instruction> instPool,
-            GeneratorPool<LiteralInteger> integerPool) : base(SpirvVersionPacked, instPool, integerPool)
-        {
-            Info = info;
-            Config = config;
-
-            if (config.Stage == ShaderStage.Geometry)
-            {
-                InputTopology inPrimitive = config.GpuAccessor.QueryPrimitiveTopology();
-
-                InputVertices = inPrimitive switch
-                {
-                    InputTopology.Points => 1,
-                    InputTopology.Lines => 2,
-                    InputTopology.LinesAdjacency => 2,
-                    InputTopology.Triangles => 3,
-                    InputTopology.TrianglesAdjacency => 3,
-                    _ => throw new InvalidOperationException($"Invalid input topology \"{inPrimitive}\".")
-                };
-            }
-
-            AddCapability(Capability.Shader);
-            AddCapability(Capability.Float64);
-
-            SetMemoryModel(AddressingModel.Logical, MemoryModel.GLSL450);
-
-            Delegates = new SpirvDelegates(this);
-        }
-
-        public void StartFunction()
-        {
-            _locals.Clear();
-            _localForArgs.Clear();
-            _funcArgs.Clear();
-        }
-
-        public void EnterBlock(AstBlock block)
-        {
-            CurrentBlock = block;
-            AddLabel(GetBlockStateLazy(block).GetNextLabelAutoIncrement(this));
-        }
-
-        public Instruction GetFirstLabel(AstBlock block)
-        {
-            return GetBlockStateLazy(block).GetLabel(this, 0);
-        }
-
-        public Instruction GetNextLabel(AstBlock block)
-        {
-            return GetBlockStateLazy(block).GetNextLabel(this);
-        }
-
-        private BlockState GetBlockStateLazy(AstBlock block)
-        {
-            if (!_labels.TryGetValue(block, out var blockState))
-            {
-                blockState = new BlockState();
-
-                _labels.Add(block, blockState);
-            }
-
-            return blockState;
-        }
-
-        public Instruction NewBlock()
-        {
-            var label = Label();
-            Branch(label);
-            AddLabel(label);
-            return label;
-        }
-
-        public Instruction[] GetMainInterface()
-        {
-            var mainInterface = new List<Instruction>();
-
-            mainInterface.AddRange(Inputs.Values);
-            mainInterface.AddRange(Outputs.Values);
-            mainInterface.AddRange(InputsPerPatch.Values);
-            mainInterface.AddRange(OutputsPerPatch.Values);
-
-            return mainInterface.ToArray();
-        }
-
-        public void DeclareLocal(AstOperand local, Instruction spvLocal)
-        {
-            _locals.Add(local, spvLocal);
-        }
-
-        public void DeclareLocalForArgs(int funcIndex, Instruction[] spvLocals)
-        {
-            _localForArgs.Add(funcIndex, spvLocals);
-        }
-
-        public void DeclareArgument(int argIndex, Instruction spvLocal)
-        {
-            _funcArgs.Add(argIndex, spvLocal);
-        }
-
-        public void DeclareFunction(int funcIndex, StructuredFunction function, Instruction spvFunc)
-        {
-            _functions.Add(funcIndex, (function, spvFunc));
-        }
-
-        public Instruction GetFP32(IAstNode node)
-        {
-            return Get(AggregateType.FP32, node);
-        }
-
-        public Instruction GetFP64(IAstNode node)
-        {
-            return Get(AggregateType.FP64, node);
-        }
-
-        public Instruction GetS32(IAstNode node)
-        {
-            return Get(AggregateType.S32, node);
-        }
-
-        public Instruction GetU32(IAstNode node)
-        {
-            return Get(AggregateType.U32, node);
-        }
-
-        public Instruction Get(AggregateType type, IAstNode node)
-        {
-            if (node is AstOperation operation)
-            {
-                var opResult = Instructions.Generate(this, operation);
-                return BitcastIfNeeded(type, opResult.Type, opResult.Value);
-            }
-            else if (node is AstOperand operand)
-            {
-                return operand.Type switch
-                {
-                    IrOperandType.Argument => GetArgument(type, operand),
-                    IrOperandType.Constant => GetConstant(type, operand),
-                    IrOperandType.ConstantBuffer => GetConstantBuffer(type, operand),
-                    IrOperandType.LocalVariable => GetLocal(type, operand),
-                    IrOperandType.Undefined => GetUndefined(type),
-                    _ => throw new ArgumentException($"Invalid operand type \"{operand.Type}\".")
-                };
-            }
-
-            throw new NotImplementedException(node.GetType().Name);
-        }
-
-        public Instruction GetWithType(IAstNode node, out AggregateType type)
-        {
-            if (node is AstOperation operation)
-            {
-                var opResult = Instructions.Generate(this, operation);
-                type = opResult.Type;
-                return opResult.Value;
-            }
-            else if (node is AstOperand operand)
-            {
-                switch (operand.Type)
-                {
-                    case IrOperandType.LocalVariable:
-                        type = operand.VarType;
-                        return GetLocal(type, operand);
-                    default:
-                        throw new ArgumentException($"Invalid operand type \"{operand.Type}\".");
-                }
-            }
-
-            throw new NotImplementedException(node.GetType().Name);
-        }
-
-        private Instruction GetUndefined(AggregateType type)
-        {
-            return type switch
-            {
-                AggregateType.Bool => ConstantFalse(TypeBool()),
-                AggregateType.FP32 => Constant(TypeFP32(), 0f),
-                AggregateType.FP64 => Constant(TypeFP64(), 0d),
-                _ => Constant(GetType(type), 0)
-            };
-        }
-
-        public Instruction GetConstant(AggregateType type, AstOperand operand)
-        {
-            return type switch
-            {
-                AggregateType.Bool => operand.Value != 0 ? ConstantTrue(TypeBool()) : ConstantFalse(TypeBool()),
-                AggregateType.FP32 => Constant(TypeFP32(), BitConverter.Int32BitsToSingle(operand.Value)),
-                AggregateType.FP64 => Constant(TypeFP64(), (double)BitConverter.Int32BitsToSingle(operand.Value)),
-                AggregateType.S32 => Constant(TypeS32(), operand.Value),
-                AggregateType.U32 => Constant(TypeU32(), (uint)operand.Value),
-                _ => throw new ArgumentException($"Invalid type \"{type}\".")
-            };
-        }
-
-        public Instruction GetConstantBuffer(AggregateType type, AstOperand operand)
-        {
-            var i1 = Constant(TypeS32(), 0);
-            var i2 = Constant(TypeS32(), operand.CbufOffset >> 2);
-            var i3 = Constant(TypeU32(), operand.CbufOffset & 3);
-
-            Instruction elemPointer;
-
-            if (UniformBuffersArray != null)
-            {
-                var ubVariable = UniformBuffersArray;
-                var i0 = Constant(TypeS32(), operand.CbufSlot);
-
-                elemPointer = AccessChain(TypePointer(StorageClass.Uniform, TypeFP32()), ubVariable, i0, i1, i2, i3);
-            }
-            else
-            {
-                var ubVariable = UniformBuffers[operand.CbufSlot];
-
-                elemPointer = AccessChain(TypePointer(StorageClass.Uniform, TypeFP32()), ubVariable, i1, i2, i3);
-            }
-
-            return BitcastIfNeeded(type, AggregateType.FP32, Load(TypeFP32(), elemPointer));
-        }
-
-        public Instruction GetLocalPointer(AstOperand local)
-        {
-            return _locals[local];
-        }
-
-        public Instruction[] GetLocalForArgsPointers(int funcIndex)
-        {
-            return _localForArgs[funcIndex];
-        }
-
-        public Instruction GetArgumentPointer(AstOperand funcArg)
-        {
-            return _funcArgs[funcArg.Value];
-        }
-
-        public Instruction GetLocal(AggregateType dstType, AstOperand local)
-        {
-            var srcType = local.VarType;
-            return BitcastIfNeeded(dstType, srcType, Load(GetType(srcType), GetLocalPointer(local)));
-        }
-
-        public Instruction GetArgument(AggregateType dstType, AstOperand funcArg)
-        {
-            var srcType = funcArg.VarType;
-            return BitcastIfNeeded(dstType, srcType, Load(GetType(srcType), GetArgumentPointer(funcArg)));
-        }
-
-        public (StructuredFunction, Instruction) GetFunction(int funcIndex)
-        {
-            return _functions[funcIndex];
-        }
-
-        public Instruction GetType(AggregateType type, int length = 1)
-        {
-            if ((type & AggregateType.Array) != 0)
-            {
-                return TypeArray(GetType(type & ~AggregateType.Array), Constant(TypeU32(), length));
-            }
-            else if ((type & AggregateType.ElementCountMask) != 0)
-            {
-                int vectorLength = (type & AggregateType.ElementCountMask) switch
-                {
-                    AggregateType.Vector2 => 2,
-                    AggregateType.Vector3 => 3,
-                    AggregateType.Vector4 => 4,
-                    _ => 1
-                };
-
-                return TypeVector(GetType(type & ~AggregateType.ElementCountMask), vectorLength);
-            }
-
-            return type switch
-            {
-                AggregateType.Void => TypeVoid(),
-                AggregateType.Bool => TypeBool(),
-                AggregateType.FP32 => TypeFP32(),
-                AggregateType.FP64 => TypeFP64(),
-                AggregateType.S32 => TypeS32(),
-                AggregateType.U32 => TypeU32(),
-                _ => throw new ArgumentException($"Invalid attribute type \"{type}\".")
-            };
-        }
-
-        public Instruction BitcastIfNeeded(AggregateType dstType, AggregateType srcType, Instruction value)
-        {
-            if (dstType == srcType)
-            {
-                return value;
-            }
-
-            if (dstType == AggregateType.Bool)
-            {
-                return INotEqual(TypeBool(), BitcastIfNeeded(AggregateType.S32, srcType, value), Constant(TypeS32(), 0));
-            }
-            else if (srcType == AggregateType.Bool)
-            {
-                var intTrue  = Constant(TypeS32(), IrConsts.True);
-                var intFalse = Constant(TypeS32(), IrConsts.False);
-
-                return BitcastIfNeeded(dstType, AggregateType.S32, Select(TypeS32(), value, intTrue, intFalse));
-            }
-            else
-            {
-                return Bitcast(GetType(dstType, 1), value);
-            }
-        }
-
-        public Instruction TypeS32()
-        {
-            return TypeInt(32, true);
-        }
-
-        public Instruction TypeU32()
-        {
-            return TypeInt(32, false);
-        }
-
-        public Instruction TypeFP32()
-        {
-            return TypeFloat(32);
-        }
-
-        public Instruction TypeFP64()
-        {
-            return TypeFloat(64);
-        }
-    }
-}
diff --git a/Ryujinx.Graphics.Shader/CodeGen/Spirv/Declarations.cs b/Ryujinx.Graphics.Shader/CodeGen/Spirv/Declarations.cs
deleted file mode 100644
index 821da477..00000000
--- a/Ryujinx.Graphics.Shader/CodeGen/Spirv/Declarations.cs
+++ /dev/null
@@ -1,615 +0,0 @@
-using Ryujinx.Common;
-using Ryujinx.Graphics.Shader.IntermediateRepresentation;
-using Ryujinx.Graphics.Shader.StructuredIr;
-using Ryujinx.Graphics.Shader.Translation;
-using Spv.Generator;
-using System;
-using System.Collections.Generic;
-using System.Linq;
-using System.Numerics;
-using static Spv.Specification;
-using SpvInstruction = Spv.Generator.Instruction;
-
-namespace Ryujinx.Graphics.Shader.CodeGen.Spirv
-{
-    static class Declarations
-    {
-        private static readonly string[] StagePrefixes = new string[] { "cp", "vp", "tcp", "tep", "gp", "fp" };
-
-        public static void DeclareParameters(CodeGenContext context, StructuredFunction function)
-        {
-            DeclareParameters(context, function.InArguments, 0);
-            DeclareParameters(context, function.OutArguments, function.InArguments.Length);
-        }
-
-        private static void DeclareParameters(CodeGenContext context, IEnumerable<AggregateType> argTypes, int argIndex)
-        {
-            foreach (var argType in argTypes)
-            {
-                var argPointerType = context.TypePointer(StorageClass.Function, context.GetType(argType));
-                var spvArg = context.FunctionParameter(argPointerType);
-
-                context.DeclareArgument(argIndex++, spvArg);
-            }
-        }
-
-        public static void DeclareLocals(CodeGenContext context, StructuredFunction function)
-        {
-            foreach (AstOperand local in function.Locals)
-            {
-                var localPointerType = context.TypePointer(StorageClass.Function, context.GetType(local.VarType));
-                var spvLocal = context.Variable(localPointerType, StorageClass.Function);
-
-                context.AddLocalVariable(spvLocal);
-                context.DeclareLocal(local, spvLocal);
-            }
-
-            var ivector2Type = context.TypeVector(context.TypeS32(), 2);
-            var coordTempPointerType = context.TypePointer(StorageClass.Function, ivector2Type);
-            var coordTemp = context.Variable(coordTempPointerType, StorageClass.Function);
-
-            context.AddLocalVariable(coordTemp);
-            context.CoordTemp = coordTemp;
-        }
-
-        public static void DeclareLocalForArgs(CodeGenContext context, List<StructuredFunction> functions)
-        {
-            for (int funcIndex = 0; funcIndex < functions.Count; funcIndex++)
-            {
-                StructuredFunction function = functions[funcIndex];
-                SpvInstruction[] locals = new SpvInstruction[function.InArguments.Length];
-
-                for (int i = 0; i < function.InArguments.Length; i++)
-                {
-                    var type = function.GetArgumentType(i);
-                    var localPointerType = context.TypePointer(StorageClass.Function, context.GetType(type));
-                    var spvLocal = context.Variable(localPointerType, StorageClass.Function);
-
-                    context.AddLocalVariable(spvLocal);
-
-                    locals[i] = spvLocal;
-                }
-
-                context.DeclareLocalForArgs(funcIndex, locals);
-            }
-        }
-
-        public static void DeclareAll(CodeGenContext context, StructuredProgramInfo info)
-        {
-            if (context.Config.Stage == ShaderStage.Compute)
-            {
-                int localMemorySize = BitUtils.DivRoundUp(context.Config.GpuAccessor.QueryComputeLocalMemorySize(), 4);
-
-                if (localMemorySize != 0)
-                {
-                    DeclareLocalMemory(context, localMemorySize);
-                }
-
-                int sharedMemorySize = BitUtils.DivRoundUp(context.Config.GpuAccessor.QueryComputeSharedMemorySize(), 4);
-
-                if (sharedMemorySize != 0)
-                {
-                    DeclareSharedMemory(context, sharedMemorySize);
-                }
-            }
-            else if (context.Config.LocalMemorySize != 0)
-            {
-                int localMemorySize = BitUtils.DivRoundUp(context.Config.LocalMemorySize, 4);
-                DeclareLocalMemory(context, localMemorySize);
-            }
-
-            DeclareSupportBuffer(context);
-            DeclareUniformBuffers(context, context.Config.GetConstantBufferDescriptors());
-            DeclareStorageBuffers(context, context.Config.GetStorageBufferDescriptors());
-            DeclareSamplers(context, context.Config.GetTextureDescriptors());
-            DeclareImages(context, context.Config.GetImageDescriptors());
-            DeclareInputsAndOutputs(context, info);
-        }
-
-        private static void DeclareLocalMemory(CodeGenContext context, int size)
-        {
-            context.LocalMemory = DeclareMemory(context, StorageClass.Private, size);
-        }
-
-        private static void DeclareSharedMemory(CodeGenContext context, int size)
-        {
-            context.SharedMemory = DeclareMemory(context, StorageClass.Workgroup, size);
-        }
-
-        private static SpvInstruction DeclareMemory(CodeGenContext context, StorageClass storage, int size)
-        {
-            var arrayType = context.TypeArray(context.TypeU32(), context.Constant(context.TypeU32(), size));
-            var pointerType = context.TypePointer(storage, arrayType);
-            var variable = context.Variable(pointerType, storage);
-
-            context.AddGlobalVariable(variable);
-
-            return variable;
-        }
-
-        private static void DeclareSupportBuffer(CodeGenContext context)
-        {
-            if (!context.Config.Stage.SupportsRenderScale() && !(context.Config.LastInVertexPipeline && context.Config.GpuAccessor.QueryViewportTransformDisable()))
-            {
-                return;
-            }
-
-            var isBgraArrayType = context.TypeArray(context.TypeU32(), context.Constant(context.TypeU32(), SupportBuffer.FragmentIsBgraCount));
-            var viewportInverseVectorType = context.TypeVector(context.TypeFP32(), 4);
-            var renderScaleArrayType = context.TypeArray(context.TypeFP32(), context.Constant(context.TypeU32(), SupportBuffer.RenderScaleMaxCount));
-
-            context.Decorate(isBgraArrayType, Decoration.ArrayStride, (LiteralInteger)SupportBuffer.FieldSize);
-            context.Decorate(renderScaleArrayType, Decoration.ArrayStride, (LiteralInteger)SupportBuffer.FieldSize);
-
-            var supportBufferStructType = context.TypeStruct(false, context.TypeU32(), isBgraArrayType, viewportInverseVectorType, context.TypeS32(), renderScaleArrayType);
-
-            context.MemberDecorate(supportBufferStructType, 0, Decoration.Offset, (LiteralInteger)SupportBuffer.FragmentAlphaTestOffset);
-            context.MemberDecorate(supportBufferStructType, 1, Decoration.Offset, (LiteralInteger)SupportBuffer.FragmentIsBgraOffset);
-            context.MemberDecorate(supportBufferStructType, 2, Decoration.Offset, (LiteralInteger)SupportBuffer.ViewportInverseOffset);
-            context.MemberDecorate(supportBufferStructType, 3, Decoration.Offset, (LiteralInteger)SupportBuffer.FragmentRenderScaleCountOffset);
-            context.MemberDecorate(supportBufferStructType, 4, Decoration.Offset, (LiteralInteger)SupportBuffer.GraphicsRenderScaleOffset);
-            context.Decorate(supportBufferStructType, Decoration.Block);
-
-            var supportBufferPointerType = context.TypePointer(StorageClass.Uniform, supportBufferStructType);
-            var supportBufferVariable = context.Variable(supportBufferPointerType, StorageClass.Uniform);
-
-            context.Decorate(supportBufferVariable, Decoration.DescriptorSet, (LiteralInteger)0);
-            context.Decorate(supportBufferVariable, Decoration.Binding, (LiteralInteger)0);
-
-            context.AddGlobalVariable(supportBufferVariable);
-
-            context.SupportBuffer = supportBufferVariable;
-        }
-
-        private static void DeclareUniformBuffers(CodeGenContext context, BufferDescriptor[] descriptors)
-        {
-            if (descriptors.Length == 0)
-            {
-                return;
-            }
-
-            uint ubSize = Constants.ConstantBufferSize / 16;
-
-            var ubArrayType = context.TypeArray(context.TypeVector(context.TypeFP32(), 4), context.Constant(context.TypeU32(), ubSize), true);
-            context.Decorate(ubArrayType, Decoration.ArrayStride, (LiteralInteger)16);
-            var ubStructType = context.TypeStruct(true, ubArrayType);
-            context.Decorate(ubStructType, Decoration.Block);
-            context.MemberDecorate(ubStructType, 0, Decoration.Offset, (LiteralInteger)0);
-
-            if (context.Config.UsedFeatures.HasFlag(FeatureFlags.CbIndexing))
-            {
-                int count = descriptors.Max(x => x.Slot) + 1;
-
-                var ubStructArrayType = context.TypeArray(ubStructType, context.Constant(context.TypeU32(), count));
-                var ubPointerType = context.TypePointer(StorageClass.Uniform, ubStructArrayType);
-                var ubVariable = context.Variable(ubPointerType, StorageClass.Uniform);
-
-                context.Name(ubVariable, $"{GetStagePrefix(context.Config.Stage)}_u");
-                context.Decorate(ubVariable, Decoration.DescriptorSet, (LiteralInteger)0);
-                context.Decorate(ubVariable, Decoration.Binding, (LiteralInteger)context.Config.FirstConstantBufferBinding);
-                context.AddGlobalVariable(ubVariable);
-
-                context.UniformBuffersArray = ubVariable;
-            }
-            else
-            {
-                var ubPointerType = context.TypePointer(StorageClass.Uniform, ubStructType);
-
-                foreach (var descriptor in descriptors)
-                {
-                    var ubVariable = context.Variable(ubPointerType, StorageClass.Uniform);
-
-                    context.Name(ubVariable, $"{GetStagePrefix(context.Config.Stage)}_c{descriptor.Slot}");
-                    context.Decorate(ubVariable, Decoration.DescriptorSet, (LiteralInteger)0);
-                    context.Decorate(ubVariable, Decoration.Binding, (LiteralInteger)descriptor.Binding);
-                    context.AddGlobalVariable(ubVariable);
-                    context.UniformBuffers.Add(descriptor.Slot, ubVariable);
-                }
-            }
-        }
-
-        private static void DeclareStorageBuffers(CodeGenContext context, BufferDescriptor[] descriptors)
-        {
-            if (descriptors.Length == 0)
-            {
-                return;
-            }
-
-            int setIndex = context.Config.Options.TargetApi == TargetApi.Vulkan ? 1 : 0;
-            int count = descriptors.Max(x => x.Slot) + 1;
-
-            var sbArrayType = context.TypeRuntimeArray(context.TypeU32());
-            context.Decorate(sbArrayType, Decoration.ArrayStride, (LiteralInteger)4);
-            var sbStructType = context.TypeStruct(true, sbArrayType);
-            context.Decorate(sbStructType, Decoration.BufferBlock);
-            context.MemberDecorate(sbStructType, 0, Decoration.Offset, (LiteralInteger)0);
-            var sbStructArrayType = context.TypeArray(sbStructType, context.Constant(context.TypeU32(), count));
-            var sbPointerType = context.TypePointer(StorageClass.Uniform, sbStructArrayType);
-            var sbVariable = context.Variable(sbPointerType, StorageClass.Uniform);
-
-            context.Name(sbVariable, $"{GetStagePrefix(context.Config.Stage)}_s");
-            context.Decorate(sbVariable, Decoration.DescriptorSet, (LiteralInteger)setIndex);
-            context.Decorate(sbVariable, Decoration.Binding, (LiteralInteger)context.Config.FirstStorageBufferBinding);
-            context.AddGlobalVariable(sbVariable);
-
-            context.StorageBuffersArray = sbVariable;
-        }
-
-        private static void DeclareSamplers(CodeGenContext context, TextureDescriptor[] descriptors)
-        {
-            foreach (var descriptor in descriptors)
-            {
-                var meta = new TextureMeta(descriptor.CbufSlot, descriptor.HandleIndex, descriptor.Format);
-
-                if (context.Samplers.ContainsKey(meta))
-                {
-                    continue;
-                }
-
-                int setIndex = context.Config.Options.TargetApi == TargetApi.Vulkan ? 2 : 0;
-
-                var dim = (descriptor.Type & SamplerType.Mask) switch
-                {
-                    SamplerType.Texture1D => Dim.Dim1D,
-                    SamplerType.Texture2D => Dim.Dim2D,
-                    SamplerType.Texture3D => Dim.Dim3D,
-                    SamplerType.TextureCube => Dim.Cube,
-                    SamplerType.TextureBuffer => Dim.Buffer,
-                    _ => throw new InvalidOperationException($"Invalid sampler type \"{descriptor.Type & SamplerType.Mask}\".")
-                };
-
-                var imageType = context.TypeImage(
-                    context.TypeFP32(),
-                    dim,
-                    descriptor.Type.HasFlag(SamplerType.Shadow),
-                    descriptor.Type.HasFlag(SamplerType.Array),
-                    descriptor.Type.HasFlag(SamplerType.Multisample),
-                    1,
-                    ImageFormat.Unknown);
-
-                var nameSuffix = meta.CbufSlot < 0 ? $"_tcb_{meta.Handle:X}" : $"_cb{meta.CbufSlot}_{meta.Handle:X}";
-
-                var sampledImageType = context.TypeSampledImage(imageType);
-                var sampledImagePointerType = context.TypePointer(StorageClass.UniformConstant, sampledImageType);
-                var sampledImageVariable = context.Variable(sampledImagePointerType, StorageClass.UniformConstant);
-
-                context.Samplers.Add(meta, (imageType, sampledImageType, sampledImageVariable));
-                context.SamplersTypes.Add(meta, descriptor.Type);
-
-                context.Name(sampledImageVariable, $"{GetStagePrefix(context.Config.Stage)}_tex{nameSuffix}");
-                context.Decorate(sampledImageVariable, Decoration.DescriptorSet, (LiteralInteger)setIndex);
-                context.Decorate(sampledImageVariable, Decoration.Binding, (LiteralInteger)descriptor.Binding);
-                context.AddGlobalVariable(sampledImageVariable);
-            }
-        }
-
-        private static void DeclareImages(CodeGenContext context, TextureDescriptor[] descriptors)
-        {
-            foreach (var descriptor in descriptors)
-            {
-                var meta = new TextureMeta(descriptor.CbufSlot, descriptor.HandleIndex, descriptor.Format);
-
-                if (context.Images.ContainsKey(meta))
-                {
-                    continue;
-                }
-
-                int setIndex = context.Config.Options.TargetApi == TargetApi.Vulkan ? 3 : 0;
-
-                var dim = GetDim(descriptor.Type);
-
-                var imageType = context.TypeImage(
-                    context.GetType(meta.Format.GetComponentType()),
-                    dim,
-                    descriptor.Type.HasFlag(SamplerType.Shadow),
-                    descriptor.Type.HasFlag(SamplerType.Array),
-                    descriptor.Type.HasFlag(SamplerType.Multisample),
-                    AccessQualifier.ReadWrite,
-                    GetImageFormat(meta.Format));
-
-                var nameSuffix = meta.CbufSlot < 0 ?
-                    $"_tcb_{meta.Handle:X}_{meta.Format.ToGlslFormat()}" :
-                    $"_cb{meta.CbufSlot}_{meta.Handle:X}_{meta.Format.ToGlslFormat()}";
-
-                var imagePointerType = context.TypePointer(StorageClass.UniformConstant, imageType);
-                var imageVariable = context.Variable(imagePointerType, StorageClass.UniformConstant);
-
-                context.Images.Add(meta, (imageType, imageVariable));
-
-                context.Name(imageVariable, $"{GetStagePrefix(context.Config.Stage)}_img{nameSuffix}");
-                context.Decorate(imageVariable, Decoration.DescriptorSet, (LiteralInteger)setIndex);
-                context.Decorate(imageVariable, Decoration.Binding, (LiteralInteger)descriptor.Binding);
-
-                if (descriptor.Flags.HasFlag(TextureUsageFlags.ImageCoherent))
-                {
-                    context.Decorate(imageVariable, Decoration.Coherent);
-                }
-
-                context.AddGlobalVariable(imageVariable);
-            }
-        }
-
-        private static Dim GetDim(SamplerType type)
-        {
-            return (type & SamplerType.Mask) switch
-            {
-                SamplerType.Texture1D => Dim.Dim1D,
-                SamplerType.Texture2D => Dim.Dim2D,
-                SamplerType.Texture3D => Dim.Dim3D,
-                SamplerType.TextureCube => Dim.Cube,
-                SamplerType.TextureBuffer => Dim.Buffer,
-                _ => throw new ArgumentException($"Invalid sampler type \"{type & SamplerType.Mask}\".")
-            };
-        }
-
-        private static ImageFormat GetImageFormat(TextureFormat format)
-        {
-            return format switch
-            {
-                TextureFormat.Unknown => ImageFormat.Unknown,
-                TextureFormat.R8Unorm => ImageFormat.R8,
-                TextureFormat.R8Snorm => ImageFormat.R8Snorm,
-                TextureFormat.R8Uint => ImageFormat.R8ui,
-                TextureFormat.R8Sint => ImageFormat.R8i,
-                TextureFormat.R16Float => ImageFormat.R16f,
-                TextureFormat.R16Unorm => ImageFormat.R16,
-                TextureFormat.R16Snorm => ImageFormat.R16Snorm,
-                TextureFormat.R16Uint => ImageFormat.R16ui,
-                TextureFormat.R16Sint => ImageFormat.R16i,
-                TextureFormat.R32Float => ImageFormat.R32f,
-                TextureFormat.R32Uint => ImageFormat.R32ui,
-                TextureFormat.R32Sint => ImageFormat.R32i,
-                TextureFormat.R8G8Unorm => ImageFormat.Rg8,
-                TextureFormat.R8G8Snorm => ImageFormat.Rg8Snorm,
-                TextureFormat.R8G8Uint => ImageFormat.Rg8ui,
-                TextureFormat.R8G8Sint => ImageFormat.Rg8i,
-                TextureFormat.R16G16Float => ImageFormat.Rg16f,
-                TextureFormat.R16G16Unorm => ImageFormat.Rg16,
-                TextureFormat.R16G16Snorm => ImageFormat.Rg16Snorm,
-                TextureFormat.R16G16Uint => ImageFormat.Rg16ui,
-                TextureFormat.R16G16Sint => ImageFormat.Rg16i,
-                TextureFormat.R32G32Float => ImageFormat.Rg32f,
-                TextureFormat.R32G32Uint => ImageFormat.Rg32ui,
-                TextureFormat.R32G32Sint => ImageFormat.Rg32i,
-                TextureFormat.R8G8B8A8Unorm => ImageFormat.Rgba8,
-                TextureFormat.R8G8B8A8Snorm => ImageFormat.Rgba8Snorm,
-                TextureFormat.R8G8B8A8Uint => ImageFormat.Rgba8ui,
-                TextureFormat.R8G8B8A8Sint => ImageFormat.Rgba8i,
-                TextureFormat.R16G16B16A16Float => ImageFormat.Rgba16f,
-                TextureFormat.R16G16B16A16Unorm => ImageFormat.Rgba16,
-                TextureFormat.R16G16B16A16Snorm => ImageFormat.Rgba16Snorm,
-                TextureFormat.R16G16B16A16Uint => ImageFormat.Rgba16ui,
-                TextureFormat.R16G16B16A16Sint => ImageFormat.Rgba16i,
-                TextureFormat.R32G32B32A32Float => ImageFormat.Rgba32f,
-                TextureFormat.R32G32B32A32Uint => ImageFormat.Rgba32ui,
-                TextureFormat.R32G32B32A32Sint => ImageFormat.Rgba32i,
-                TextureFormat.R10G10B10A2Unorm => ImageFormat.Rgb10A2,
-                TextureFormat.R10G10B10A2Uint => ImageFormat.Rgb10a2ui,
-                TextureFormat.R11G11B10Float => ImageFormat.R11fG11fB10f,
-                _ => throw new ArgumentException($"Invalid texture format \"{format}\".")
-            };
-        }
-
-        private static void DeclareInputsAndOutputs(CodeGenContext context, StructuredProgramInfo info)
-        {
-            foreach (var ioDefinition in info.IoDefinitions)
-            {
-                var ioVariable = ioDefinition.IoVariable;
-
-                // Those are actually from constant buffer, rather than being actual inputs or outputs,
-                // so we must ignore them here as they are declared as part of the support buffer.
-                // TODO: Delete this after we represent this properly on the IR (as a constant buffer rather than "input").
-                if (ioVariable == IoVariable.FragmentOutputIsBgra ||
-                    ioVariable == IoVariable.SupportBlockRenderScale ||
-                    ioVariable == IoVariable.SupportBlockViewInverse)
-                {
-                    continue;
-                }
-
-                bool isOutput = ioDefinition.StorageKind.IsOutput();
-                bool isPerPatch = ioDefinition.StorageKind.IsPerPatch();
-
-                PixelImap iq = PixelImap.Unused;
-
-                if (context.Config.Stage == ShaderStage.Fragment)
-                {
-                    if (ioVariable == IoVariable.UserDefined)
-                    {
-                        iq = context.Config.ImapTypes[ioDefinition.Location].GetFirstUsedType();
-                    }
-                    else
-                    {
-                        (_, AggregateType varType) = IoMap.GetSpirvBuiltIn(ioVariable);
-                        AggregateType elemType = varType & AggregateType.ElementTypeMask;
-
-                        if (elemType == AggregateType.S32 || elemType == AggregateType.U32)
-                        {
-                            iq = PixelImap.Constant;
-                        }
-                    }
-                }
-
-                DeclareInputOrOutput(context, ioDefinition, isOutput, isPerPatch, iq);
-            }
-        }
-
-        private static void DeclareInputOrOutput(CodeGenContext context, IoDefinition ioDefinition, bool isOutput, bool isPerPatch, PixelImap iq = PixelImap.Unused)
-        {
-            IoVariable ioVariable = ioDefinition.IoVariable;
-            var storageClass = isOutput ? StorageClass.Output : StorageClass.Input;
-
-            bool isBuiltIn;
-            BuiltIn builtIn = default;
-            AggregateType varType;
-
-            if (ioVariable == IoVariable.UserDefined)
-            {
-                varType = context.Config.GetUserDefinedType(ioDefinition.Location, isOutput);
-                isBuiltIn = false;
-            }
-            else if (ioVariable == IoVariable.FragmentOutputColor)
-            {
-                varType = context.Config.GetFragmentOutputColorType(ioDefinition.Location);
-                isBuiltIn = false;
-            }
-            else
-            {
-                (builtIn, varType) = IoMap.GetSpirvBuiltIn(ioVariable);
-                isBuiltIn = true;
-
-                if (varType == AggregateType.Invalid)
-                {
-                    throw new InvalidOperationException($"Unknown variable {ioVariable}.");
-                }
-            }
-
-            bool hasComponent = context.Config.HasPerLocationInputOrOutputComponent(ioVariable, ioDefinition.Location, ioDefinition.Component, isOutput);
-
-            if (hasComponent)
-            {
-                varType &= AggregateType.ElementTypeMask;
-            }
-            else if (ioVariable == IoVariable.UserDefined && context.Config.HasTransformFeedbackOutputs(isOutput))
-            {
-                varType &= AggregateType.ElementTypeMask;
-                varType |= context.Config.GetTransformFeedbackOutputComponents(ioDefinition.Location, ioDefinition.Component) switch
-                {
-                    2 => AggregateType.Vector2,
-                    3 => AggregateType.Vector3,
-                    4 => AggregateType.Vector4,
-                    _ => AggregateType.Invalid
-                };
-            }
-
-            var spvType = context.GetType(varType, IoMap.GetSpirvBuiltInArrayLength(ioVariable));
-            bool builtInPassthrough = false;
-
-            if (!isPerPatch && IoMap.IsPerVertex(ioVariable, context.Config.Stage, isOutput))
-            {
-                int arraySize = context.Config.Stage == ShaderStage.Geometry ? context.InputVertices : 32;
-                spvType = context.TypeArray(spvType, context.Constant(context.TypeU32(), (LiteralInteger)arraySize));
-
-                if (context.Config.GpPassthrough && context.Config.GpuAccessor.QueryHostSupportsGeometryShaderPassthrough())
-                {
-                    builtInPassthrough = true;
-                }
-            }
-
-            if (context.Config.Stage == ShaderStage.TessellationControl && isOutput && !isPerPatch)
-            {
-                spvType = context.TypeArray(spvType, context.Constant(context.TypeU32(), context.Config.ThreadsPerInputPrimitive));
-            }
-
-            var spvPointerType = context.TypePointer(storageClass, spvType);
-            var spvVar = context.Variable(spvPointerType, storageClass);
-
-            if (builtInPassthrough)
-            {
-                context.Decorate(spvVar, Decoration.PassthroughNV);
-            }
-
-            if (isBuiltIn)
-            {
-                if (isPerPatch)
-                {
-                    context.Decorate(spvVar, Decoration.Patch);
-                }
-
-                if (context.Config.GpuAccessor.QueryHostReducedPrecision() && ioVariable == IoVariable.Position)
-                {
-                    context.Decorate(spvVar, Decoration.Invariant);
-                }
-
-                context.Decorate(spvVar, Decoration.BuiltIn, (LiteralInteger)builtIn);
-            }
-            else if (isPerPatch)
-            {
-                context.Decorate(spvVar, Decoration.Patch);
-
-                if (ioVariable == IoVariable.UserDefined)
-                {
-                    int location = context.Config.GetPerPatchAttributeLocation(ioDefinition.Location);
-
-                    context.Decorate(spvVar, Decoration.Location, (LiteralInteger)location);
-                }
-            }
-            else if (ioVariable == IoVariable.UserDefined)
-            {
-                context.Decorate(spvVar, Decoration.Location, (LiteralInteger)ioDefinition.Location);
-
-                if (hasComponent)
-                {
-                    context.Decorate(spvVar, Decoration.Component, (LiteralInteger)ioDefinition.Component);
-                }
-
-                if (!isOutput &&
-                    !isPerPatch &&
-                    (context.Config.PassthroughAttributes & (1 << ioDefinition.Location)) != 0 &&
-                    context.Config.GpuAccessor.QueryHostSupportsGeometryShaderPassthrough())
-                {
-                    context.Decorate(spvVar, Decoration.PassthroughNV);
-                }
-            }
-            else if (ioVariable == IoVariable.FragmentOutputColor)
-            {
-                int location = ioDefinition.Location;
-
-                if (context.Config.Stage == ShaderStage.Fragment && context.Config.GpuAccessor.QueryDualSourceBlendEnable())
-                {
-                    int firstLocation = BitOperations.TrailingZeroCount(context.Config.UsedOutputAttributes);
-                    int index = location - firstLocation;
-                    int mask = 3 << firstLocation;
-
-                    if ((uint)index < 2 && (context.Config.UsedOutputAttributes & mask) == mask)
-                    {
-                        context.Decorate(spvVar, Decoration.Location, (LiteralInteger)firstLocation);
-                        context.Decorate(spvVar, Decoration.Index, (LiteralInteger)index);
-                    }
-                    else
-                    {
-                        context.Decorate(spvVar, Decoration.Location, (LiteralInteger)location);
-                    }
-                }
-                else
-                {
-                    context.Decorate(spvVar, Decoration.Location, (LiteralInteger)location);
-                }
-            }
-
-            if (!isOutput)
-            {
-                switch (iq)
-                {
-                    case PixelImap.Constant:
-                        context.Decorate(spvVar, Decoration.Flat);
-                        break;
-                    case PixelImap.ScreenLinear:
-                        context.Decorate(spvVar, Decoration.NoPerspective);
-                        break;
-                }
-            }
-            else if (context.Config.TryGetTransformFeedbackOutput(
-                ioVariable,
-                ioDefinition.Location,
-                ioDefinition.Component,
-                out var transformFeedbackOutput))
-            {
-                context.Decorate(spvVar, Decoration.XfbBuffer, (LiteralInteger)transformFeedbackOutput.Buffer);
-                context.Decorate(spvVar, Decoration.XfbStride, (LiteralInteger)transformFeedbackOutput.Stride);
-                context.Decorate(spvVar, Decoration.Offset, (LiteralInteger)transformFeedbackOutput.Offset);
-            }
-
-            context.AddGlobalVariable(spvVar);
-
-            var dict = isPerPatch
-                ? (isOutput ? context.OutputsPerPatch : context.InputsPerPatch)
-                : (isOutput ? context.Outputs : context.Inputs);
-            dict.Add(ioDefinition, spvVar);
-        }
-
-        private static string GetStagePrefix(ShaderStage stage)
-        {
-            return StagePrefixes[(int)stage];
-        }
-    }
-}
diff --git a/Ryujinx.Graphics.Shader/CodeGen/Spirv/EnumConversion.cs b/Ryujinx.Graphics.Shader/CodeGen/Spirv/EnumConversion.cs
deleted file mode 100644
index 72541774..00000000
--- a/Ryujinx.Graphics.Shader/CodeGen/Spirv/EnumConversion.cs
+++ /dev/null
@@ -1,22 +0,0 @@
-using System;
-using static Spv.Specification;
-
-namespace Ryujinx.Graphics.Shader.CodeGen.Spirv
-{
-    static class EnumConversion
-    {
-        public static ExecutionModel Convert(this ShaderStage stage)
-        {
-            return stage switch
-            {
-                ShaderStage.Compute => ExecutionModel.GLCompute,
-                ShaderStage.Vertex => ExecutionModel.Vertex,
-                ShaderStage.TessellationControl => ExecutionModel.TessellationControl,
-                ShaderStage.TessellationEvaluation => ExecutionModel.TessellationEvaluation,
-                ShaderStage.Geometry => ExecutionModel.Geometry,
-                ShaderStage.Fragment => ExecutionModel.Fragment,
-                _ => throw new ArgumentException($"Invalid shader stage \"{stage}\".")
-            };
-        }
-    }
-}
diff --git a/Ryujinx.Graphics.Shader/CodeGen/Spirv/Instructions.cs b/Ryujinx.Graphics.Shader/CodeGen/Spirv/Instructions.cs
deleted file mode 100644
index b6ffdb7a..00000000
--- a/Ryujinx.Graphics.Shader/CodeGen/Spirv/Instructions.cs
+++ /dev/null
@@ -1,2480 +0,0 @@
-using Ryujinx.Graphics.Shader.IntermediateRepresentation;
-using Ryujinx.Graphics.Shader.StructuredIr;
-using Ryujinx.Graphics.Shader.Translation;
-using System;
-using System.Collections.Generic;
-using System.Diagnostics;
-using System.Linq;
-using System.Numerics;
-using static Spv.Specification;
-
-namespace Ryujinx.Graphics.Shader.CodeGen.Spirv
-{
-    using SpvInstruction = Spv.Generator.Instruction;
-    using SpvLiteralInteger = Spv.Generator.LiteralInteger;
-
-    static class Instructions
-    {
-        private const  MemorySemanticsMask DefaultMemorySemantics =
-            MemorySemanticsMask.ImageMemory |
-            MemorySemanticsMask.AtomicCounterMemory |
-            MemorySemanticsMask.WorkgroupMemory |
-            MemorySemanticsMask.UniformMemory |
-            MemorySemanticsMask.AcquireRelease;
-
-        private static readonly Func<CodeGenContext, AstOperation, OperationResult>[] InstTable;
-
-        static Instructions()
-        {
-            InstTable = new Func<CodeGenContext, AstOperation, OperationResult>[(int)Instruction.Count];
-
-            Add(Instruction.Absolute,                 GenerateAbsolute);
-            Add(Instruction.Add,                      GenerateAdd);
-            Add(Instruction.AtomicAdd,                GenerateAtomicAdd);
-            Add(Instruction.AtomicAnd,                GenerateAtomicAnd);
-            Add(Instruction.AtomicCompareAndSwap,     GenerateAtomicCompareAndSwap);
-            Add(Instruction.AtomicMinS32,             GenerateAtomicMinS32);
-            Add(Instruction.AtomicMinU32,             GenerateAtomicMinU32);
-            Add(Instruction.AtomicMaxS32,             GenerateAtomicMaxS32);
-            Add(Instruction.AtomicMaxU32,             GenerateAtomicMaxU32);
-            Add(Instruction.AtomicOr,                 GenerateAtomicOr);
-            Add(Instruction.AtomicSwap,               GenerateAtomicSwap);
-            Add(Instruction.AtomicXor,                GenerateAtomicXor);
-            Add(Instruction.Ballot,                   GenerateBallot);
-            Add(Instruction.Barrier,                  GenerateBarrier);
-            Add(Instruction.BitCount,                 GenerateBitCount);
-            Add(Instruction.BitfieldExtractS32,       GenerateBitfieldExtractS32);
-            Add(Instruction.BitfieldExtractU32,       GenerateBitfieldExtractU32);
-            Add(Instruction.BitfieldInsert,           GenerateBitfieldInsert);
-            Add(Instruction.BitfieldReverse,          GenerateBitfieldReverse);
-            Add(Instruction.BitwiseAnd,               GenerateBitwiseAnd);
-            Add(Instruction.BitwiseExclusiveOr,       GenerateBitwiseExclusiveOr);
-            Add(Instruction.BitwiseNot,               GenerateBitwiseNot);
-            Add(Instruction.BitwiseOr,                GenerateBitwiseOr);
-            Add(Instruction.Call,                     GenerateCall);
-            Add(Instruction.Ceiling,                  GenerateCeiling);
-            Add(Instruction.Clamp,                    GenerateClamp);
-            Add(Instruction.ClampU32,                 GenerateClampU32);
-            Add(Instruction.Comment,                  GenerateComment);
-            Add(Instruction.CompareEqual,             GenerateCompareEqual);
-            Add(Instruction.CompareGreater,           GenerateCompareGreater);
-            Add(Instruction.CompareGreaterOrEqual,    GenerateCompareGreaterOrEqual);
-            Add(Instruction.CompareGreaterOrEqualU32, GenerateCompareGreaterOrEqualU32);
-            Add(Instruction.CompareGreaterU32,        GenerateCompareGreaterU32);
-            Add(Instruction.CompareLess,              GenerateCompareLess);
-            Add(Instruction.CompareLessOrEqual,       GenerateCompareLessOrEqual);
-            Add(Instruction.CompareLessOrEqualU32,    GenerateCompareLessOrEqualU32);
-            Add(Instruction.CompareLessU32,           GenerateCompareLessU32);
-            Add(Instruction.CompareNotEqual,          GenerateCompareNotEqual);
-            Add(Instruction.ConditionalSelect,        GenerateConditionalSelect);
-            Add(Instruction.ConvertFP32ToFP64,        GenerateConvertFP32ToFP64);
-            Add(Instruction.ConvertFP32ToS32,         GenerateConvertFP32ToS32);
-            Add(Instruction.ConvertFP32ToU32,         GenerateConvertFP32ToU32);
-            Add(Instruction.ConvertFP64ToFP32,        GenerateConvertFP64ToFP32);
-            Add(Instruction.ConvertFP64ToS32,         GenerateConvertFP64ToS32);
-            Add(Instruction.ConvertFP64ToU32,         GenerateConvertFP64ToU32);
-            Add(Instruction.ConvertS32ToFP32,         GenerateConvertS32ToFP32);
-            Add(Instruction.ConvertS32ToFP64,         GenerateConvertS32ToFP64);
-            Add(Instruction.ConvertU32ToFP32,         GenerateConvertU32ToFP32);
-            Add(Instruction.ConvertU32ToFP64,         GenerateConvertU32ToFP64);
-            Add(Instruction.Cosine,                   GenerateCosine);
-            Add(Instruction.Ddx,                      GenerateDdx);
-            Add(Instruction.Ddy,                      GenerateDdy);
-            Add(Instruction.Discard,                  GenerateDiscard);
-            Add(Instruction.Divide,                   GenerateDivide);
-            Add(Instruction.EmitVertex,               GenerateEmitVertex);
-            Add(Instruction.EndPrimitive,             GenerateEndPrimitive);
-            Add(Instruction.ExponentB2,               GenerateExponentB2);
-            Add(Instruction.FSIBegin,                 GenerateFSIBegin);
-            Add(Instruction.FSIEnd,                   GenerateFSIEnd);
-            Add(Instruction.FindLSB,                  GenerateFindLSB);
-            Add(Instruction.FindMSBS32,               GenerateFindMSBS32);
-            Add(Instruction.FindMSBU32,               GenerateFindMSBU32);
-            Add(Instruction.Floor,                    GenerateFloor);
-            Add(Instruction.FusedMultiplyAdd,         GenerateFusedMultiplyAdd);
-            Add(Instruction.GroupMemoryBarrier,       GenerateGroupMemoryBarrier);
-            Add(Instruction.ImageAtomic,              GenerateImageAtomic);
-            Add(Instruction.ImageLoad,                GenerateImageLoad);
-            Add(Instruction.ImageStore,               GenerateImageStore);
-            Add(Instruction.IsNan,                    GenerateIsNan);
-            Add(Instruction.Load,                     GenerateLoad);
-            Add(Instruction.LoadConstant,             GenerateLoadConstant);
-            Add(Instruction.LoadLocal,                GenerateLoadLocal);
-            Add(Instruction.LoadShared,               GenerateLoadShared);
-            Add(Instruction.LoadStorage,              GenerateLoadStorage);
-            Add(Instruction.Lod,                      GenerateLod);
-            Add(Instruction.LogarithmB2,              GenerateLogarithmB2);
-            Add(Instruction.LogicalAnd,               GenerateLogicalAnd);
-            Add(Instruction.LogicalExclusiveOr,       GenerateLogicalExclusiveOr);
-            Add(Instruction.LogicalNot,               GenerateLogicalNot);
-            Add(Instruction.LogicalOr,                GenerateLogicalOr);
-            Add(Instruction.LoopBreak,                GenerateLoopBreak);
-            Add(Instruction.LoopContinue,             GenerateLoopContinue);
-            Add(Instruction.Maximum,                  GenerateMaximum);
-            Add(Instruction.MaximumU32,               GenerateMaximumU32);
-            Add(Instruction.MemoryBarrier,            GenerateMemoryBarrier);
-            Add(Instruction.Minimum,                  GenerateMinimum);
-            Add(Instruction.MinimumU32,               GenerateMinimumU32);
-            Add(Instruction.Multiply,                 GenerateMultiply);
-            Add(Instruction.MultiplyHighS32,          GenerateMultiplyHighS32);
-            Add(Instruction.MultiplyHighU32,          GenerateMultiplyHighU32);
-            Add(Instruction.Negate,                   GenerateNegate);
-            Add(Instruction.PackDouble2x32,           GeneratePackDouble2x32);
-            Add(Instruction.PackHalf2x16,             GeneratePackHalf2x16);
-            Add(Instruction.ReciprocalSquareRoot,     GenerateReciprocalSquareRoot);
-            Add(Instruction.Return,                   GenerateReturn);
-            Add(Instruction.Round,                    GenerateRound);
-            Add(Instruction.ShiftLeft,                GenerateShiftLeft);
-            Add(Instruction.ShiftRightS32,            GenerateShiftRightS32);
-            Add(Instruction.ShiftRightU32,            GenerateShiftRightU32);
-            Add(Instruction.Shuffle,                  GenerateShuffle);
-            Add(Instruction.ShuffleDown,              GenerateShuffleDown);
-            Add(Instruction.ShuffleUp,                GenerateShuffleUp);
-            Add(Instruction.ShuffleXor,               GenerateShuffleXor);
-            Add(Instruction.Sine,                     GenerateSine);
-            Add(Instruction.SquareRoot,               GenerateSquareRoot);
-            Add(Instruction.Store,                    GenerateStore);
-            Add(Instruction.StoreLocal,               GenerateStoreLocal);
-            Add(Instruction.StoreShared,              GenerateStoreShared);
-            Add(Instruction.StoreShared16,            GenerateStoreShared16);
-            Add(Instruction.StoreShared8,             GenerateStoreShared8);
-            Add(Instruction.StoreStorage,             GenerateStoreStorage);
-            Add(Instruction.StoreStorage16,           GenerateStoreStorage16);
-            Add(Instruction.StoreStorage8,            GenerateStoreStorage8);
-            Add(Instruction.Subtract,                 GenerateSubtract);
-            Add(Instruction.SwizzleAdd,               GenerateSwizzleAdd);
-            Add(Instruction.TextureSample,            GenerateTextureSample);
-            Add(Instruction.TextureSize,              GenerateTextureSize);
-            Add(Instruction.Truncate,                 GenerateTruncate);
-            Add(Instruction.UnpackDouble2x32,         GenerateUnpackDouble2x32);
-            Add(Instruction.UnpackHalf2x16,           GenerateUnpackHalf2x16);
-            Add(Instruction.VectorExtract,            GenerateVectorExtract);
-            Add(Instruction.VoteAll,                  GenerateVoteAll);
-            Add(Instruction.VoteAllEqual,             GenerateVoteAllEqual);
-            Add(Instruction.VoteAny,                  GenerateVoteAny);
-        }
-
-        private static void Add(Instruction inst, Func<CodeGenContext, AstOperation, OperationResult> handler)
-        {
-            InstTable[(int)(inst & Instruction.Mask)] = handler;
-        }
-
-        public static OperationResult Generate(CodeGenContext context, AstOperation operation)
-        {
-            var handler = InstTable[(int)(operation.Inst & Instruction.Mask)];
-            if (handler != null)
-            {
-                return handler(context, operation);
-            }
-            else
-            {
-                throw new NotImplementedException(operation.Inst.ToString());
-            }
-        }
-
-        private static OperationResult GenerateAbsolute(CodeGenContext context, AstOperation operation)
-        {
-            return GenerateUnary(context, operation, context.Delegates.GlslFAbs, context.Delegates.GlslSAbs);
-        }
-
-        private static OperationResult GenerateAdd(CodeGenContext context, AstOperation operation)
-        {
-            return GenerateBinary(context, operation, context.Delegates.FAdd, context.Delegates.IAdd);
-        }
-
-        private static OperationResult GenerateAtomicAdd(CodeGenContext context, AstOperation operation)
-        {
-            return GenerateAtomicMemoryBinary(context, operation, context.Delegates.AtomicIAdd);
-        }
-
-        private static OperationResult GenerateAtomicAnd(CodeGenContext context, AstOperation operation)
-        {
-            return GenerateAtomicMemoryBinary(context, operation, context.Delegates.AtomicAnd);
-        }
-
-        private static OperationResult GenerateAtomicCompareAndSwap(CodeGenContext context, AstOperation operation)
-        {
-            return GenerateAtomicMemoryCas(context, operation);
-        }
-
-        private static OperationResult GenerateAtomicMinS32(CodeGenContext context, AstOperation operation)
-        {
-            return GenerateAtomicMemoryBinary(context, operation, context.Delegates.AtomicSMin);
-        }
-
-        private static OperationResult GenerateAtomicMinU32(CodeGenContext context, AstOperation operation)
-        {
-            return GenerateAtomicMemoryBinary(context, operation, context.Delegates.AtomicUMin);
-        }
-
-        private static OperationResult GenerateAtomicMaxS32(CodeGenContext context, AstOperation operation)
-        {
-            return GenerateAtomicMemoryBinary(context, operation, context.Delegates.AtomicSMax);
-        }
-
-        private static OperationResult GenerateAtomicMaxU32(CodeGenContext context, AstOperation operation)
-        {
-            return GenerateAtomicMemoryBinary(context, operation, context.Delegates.AtomicUMax);
-        }
-
-        private static OperationResult GenerateAtomicOr(CodeGenContext context, AstOperation operation)
-        {
-            return GenerateAtomicMemoryBinary(context, operation, context.Delegates.AtomicOr);
-        }
-
-        private static OperationResult GenerateAtomicSwap(CodeGenContext context, AstOperation operation)
-        {
-            return GenerateAtomicMemoryBinary(context, operation, context.Delegates.AtomicExchange);
-        }
-
-        private static OperationResult GenerateAtomicXor(CodeGenContext context, AstOperation operation)
-        {
-            return GenerateAtomicMemoryBinary(context, operation, context.Delegates.AtomicXor);
-        }
-
-        private static OperationResult GenerateBallot(CodeGenContext context, AstOperation operation)
-        {
-            var source = operation.GetSource(0);
-
-            var uvec4Type = context.TypeVector(context.TypeU32(), 4);
-            var execution = context.Constant(context.TypeU32(), Scope.Subgroup);
-
-            var maskVector = context.GroupNonUniformBallot(uvec4Type, execution, context.Get(AggregateType.Bool, source));
-            var mask = context.CompositeExtract(context.TypeU32(), maskVector, (SpvLiteralInteger)0);
-
-            return new OperationResult(AggregateType.U32, mask);
-        }
-
-        private static OperationResult GenerateBarrier(CodeGenContext context, AstOperation operation)
-        {
-            context.ControlBarrier(
-                context.Constant(context.TypeU32(), Scope.Workgroup),
-                context.Constant(context.TypeU32(), Scope.Workgroup),
-                context.Constant(context.TypeU32(), MemorySemanticsMask.WorkgroupMemory | MemorySemanticsMask.AcquireRelease));
-
-            return OperationResult.Invalid;
-        }
-
-        private static OperationResult GenerateBitCount(CodeGenContext context, AstOperation operation)
-        {
-            return GenerateUnaryS32(context, operation, context.Delegates.BitCount);
-        }
-
-        private static OperationResult GenerateBitfieldExtractS32(CodeGenContext context, AstOperation operation)
-        {
-            return GenerateBitfieldExtractS32(context, operation, context.Delegates.BitFieldSExtract);
-        }
-
-        private static OperationResult GenerateBitfieldExtractU32(CodeGenContext context, AstOperation operation)
-        {
-            return GenerateTernaryU32(context, operation, context.Delegates.BitFieldUExtract);
-        }
-
-        private static OperationResult GenerateBitfieldInsert(CodeGenContext context, AstOperation operation)
-        {
-            return GenerateBitfieldInsert(context, operation, context.Delegates.BitFieldInsert);
-        }
-
-        private static OperationResult GenerateBitfieldReverse(CodeGenContext context, AstOperation operation)
-        {
-            return GenerateUnaryS32(context, operation, context.Delegates.BitReverse);
-        }
-
-        private static OperationResult GenerateBitwiseAnd(CodeGenContext context, AstOperation operation)
-        {
-            return GenerateBinaryS32(context, operation, context.Delegates.BitwiseAnd);
-        }
-
-        private static OperationResult GenerateBitwiseExclusiveOr(CodeGenContext context, AstOperation operation)
-        {
-            return GenerateBinaryS32(context, operation, context.Delegates.BitwiseXor);
-        }
-
-        private static OperationResult GenerateBitwiseNot(CodeGenContext context, AstOperation operation)
-        {
-            return GenerateUnaryS32(context, operation, context.Delegates.Not);
-        }
-
-        private static OperationResult GenerateBitwiseOr(CodeGenContext context, AstOperation operation)
-        {
-            return GenerateBinaryS32(context, operation, context.Delegates.BitwiseOr);
-        }
-
-        private static OperationResult GenerateCall(CodeGenContext context, AstOperation operation)
-        {
-            AstOperand funcId = (AstOperand)operation.GetSource(0);
-
-            Debug.Assert(funcId.Type == OperandType.Constant);
-
-            (var function, var spvFunc) = context.GetFunction(funcId.Value);
-
-            var args = new SpvInstruction[operation.SourcesCount - 1];
-            var spvLocals = context.GetLocalForArgsPointers(funcId.Value);
-
-            for (int i = 0; i < args.Length; i++)
-            {
-                var operand = (AstOperand)operation.GetSource(i + 1);
-                if (i >= function.InArguments.Length)
-                {
-                    args[i] = context.GetLocalPointer(operand);
-                }
-                else
-                {
-                    var type = function.GetArgumentType(i);
-                    var value = context.Get(type, operand);
-                    var spvLocal = spvLocals[i];
-
-                    context.Store(spvLocal, value);
-
-                    args[i] = spvLocal;
-                }
-            }
-
-            var retType = function.ReturnType;
-            var result = context.FunctionCall(context.GetType(retType), spvFunc, args);
-            return new OperationResult(retType, result);
-        }
-
-        private static OperationResult GenerateCeiling(CodeGenContext context, AstOperation operation)
-        {
-            return GenerateUnary(context, operation, context.Delegates.GlslCeil, null);
-        }
-
-        private static OperationResult GenerateClamp(CodeGenContext context, AstOperation operation)
-        {
-            return GenerateTernary(context, operation, context.Delegates.GlslFClamp, context.Delegates.GlslSClamp);
-        }
-
-        private static OperationResult GenerateClampU32(CodeGenContext context, AstOperation operation)
-        {
-            return GenerateTernaryU32(context, operation, context.Delegates.GlslUClamp);
-        }
-
-        private static OperationResult GenerateComment(CodeGenContext context, AstOperation operation)
-        {
-            return OperationResult.Invalid;
-        }
-
-        private static OperationResult GenerateCompareEqual(CodeGenContext context, AstOperation operation)
-        {
-            return GenerateCompare(context, operation, context.Delegates.FOrdEqual, context.Delegates.IEqual);
-        }
-
-        private static OperationResult GenerateCompareGreater(CodeGenContext context, AstOperation operation)
-        {
-            return GenerateCompare(context, operation, context.Delegates.FOrdGreaterThan, context.Delegates.SGreaterThan);
-        }
-
-        private static OperationResult GenerateCompareGreaterOrEqual(CodeGenContext context, AstOperation operation)
-        {
-            return GenerateCompare(context, operation, context.Delegates.FOrdGreaterThanEqual, context.Delegates.SGreaterThanEqual);
-        }
-
-        private static OperationResult GenerateCompareGreaterOrEqualU32(CodeGenContext context, AstOperation operation)
-        {
-            return GenerateCompareU32(context, operation, context.Delegates.UGreaterThanEqual);
-        }
-
-        private static OperationResult GenerateCompareGreaterU32(CodeGenContext context, AstOperation operation)
-        {
-            return GenerateCompareU32(context, operation, context.Delegates.UGreaterThan);
-        }
-
-        private static OperationResult GenerateCompareLess(CodeGenContext context, AstOperation operation)
-        {
-            return GenerateCompare(context, operation, context.Delegates.FOrdLessThan, context.Delegates.SLessThan);
-        }
-
-        private static OperationResult GenerateCompareLessOrEqual(CodeGenContext context, AstOperation operation)
-        {
-            return GenerateCompare(context, operation, context.Delegates.FOrdLessThanEqual, context.Delegates.SLessThanEqual);
-        }
-
-        private static OperationResult GenerateCompareLessOrEqualU32(CodeGenContext context, AstOperation operation)
-        {
-            return GenerateCompareU32(context, operation, context.Delegates.ULessThanEqual);
-        }
-
-        private static OperationResult GenerateCompareLessU32(CodeGenContext context, AstOperation operation)
-        {
-            return GenerateCompareU32(context, operation, context.Delegates.ULessThan);
-        }
-
-        private static OperationResult GenerateCompareNotEqual(CodeGenContext context, AstOperation operation)
-        {
-            return GenerateCompare(context, operation, context.Delegates.FOrdNotEqual, context.Delegates.INotEqual);
-        }
-
-        private static OperationResult GenerateConditionalSelect(CodeGenContext context, AstOperation operation)
-        {
-            var src1 = operation.GetSource(0);
-            var src2 = operation.GetSource(1);
-            var src3 = operation.GetSource(2);
-
-            var cond = context.Get(AggregateType.Bool, src1);
-
-            if (operation.Inst.HasFlag(Instruction.FP64))
-            {
-                return new OperationResult(AggregateType.FP64, context.Select(context.TypeFP64(), cond, context.GetFP64(src2), context.GetFP64(src3)));
-            }
-            else if (operation.Inst.HasFlag(Instruction.FP32))
-            {
-                return new OperationResult(AggregateType.FP32, context.Select(context.TypeFP32(), cond, context.GetFP32(src2), context.GetFP32(src3)));
-            }
-            else
-            {
-                return new OperationResult(AggregateType.S32, context.Select(context.TypeS32(), cond, context.GetS32(src2), context.GetS32(src3)));
-            }
-        }
-
-        private static OperationResult GenerateConvertFP32ToFP64(CodeGenContext context, AstOperation operation)
-        {
-            var source = operation.GetSource(0);
-
-            return new OperationResult(AggregateType.FP64, context.FConvert(context.TypeFP64(), context.GetFP32(source)));
-        }
-
-        private static OperationResult GenerateConvertFP32ToS32(CodeGenContext context, AstOperation operation)
-        {
-            var source = operation.GetSource(0);
-
-            return new OperationResult(AggregateType.S32, context.ConvertFToS(context.TypeS32(), context.GetFP32(source)));
-        }
-
-        private static OperationResult GenerateConvertFP32ToU32(CodeGenContext context, AstOperation operation)
-        {
-            var source = operation.GetSource(0);
-
-            return new OperationResult(AggregateType.U32, context.ConvertFToU(context.TypeU32(), context.GetFP32(source)));
-        }
-
-        private static OperationResult GenerateConvertFP64ToFP32(CodeGenContext context, AstOperation operation)
-        {
-            var source = operation.GetSource(0);
-
-            return new OperationResult(AggregateType.FP32, context.FConvert(context.TypeFP32(), context.GetFP64(source)));
-        }
-
-        private static OperationResult GenerateConvertFP64ToS32(CodeGenContext context, AstOperation operation)
-        {
-            var source = operation.GetSource(0);
-
-            return new OperationResult(AggregateType.S32, context.ConvertFToS(context.TypeS32(), context.GetFP64(source)));
-        }
-
-        private static OperationResult GenerateConvertFP64ToU32(CodeGenContext context, AstOperation operation)
-        {
-            var source = operation.GetSource(0);
-
-            return new OperationResult(AggregateType.U32, context.ConvertFToU(context.TypeU32(), context.GetFP64(source)));
-        }
-
-        private static OperationResult GenerateConvertS32ToFP32(CodeGenContext context, AstOperation operation)
-        {
-            var source = operation.GetSource(0);
-
-            return new OperationResult(AggregateType.FP32, context.ConvertSToF(context.TypeFP32(), context.GetS32(source)));
-        }
-
-        private static OperationResult GenerateConvertS32ToFP64(CodeGenContext context, AstOperation operation)
-        {
-            var source = operation.GetSource(0);
-
-            return new OperationResult(AggregateType.FP64, context.ConvertSToF(context.TypeFP64(), context.GetS32(source)));
-        }
-
-        private static OperationResult GenerateConvertU32ToFP32(CodeGenContext context, AstOperation operation)
-        {
-            var source = operation.GetSource(0);
-
-            return new OperationResult(AggregateType.FP32, context.ConvertUToF(context.TypeFP32(), context.GetU32(source)));
-        }
-
-        private static OperationResult GenerateConvertU32ToFP64(CodeGenContext context, AstOperation operation)
-        {
-            var source = operation.GetSource(0);
-
-            return new OperationResult(AggregateType.FP64, context.ConvertUToF(context.TypeFP64(), context.GetU32(source)));
-        }
-
-        private static OperationResult GenerateCosine(CodeGenContext context, AstOperation operation)
-        {
-            return GenerateUnary(context, operation, context.Delegates.GlslCos, null);
-        }
-
-        private static OperationResult GenerateDdx(CodeGenContext context, AstOperation operation)
-        {
-            return GenerateUnaryFP32(context, operation, context.Delegates.DPdx);
-        }
-
-        private static OperationResult GenerateDdy(CodeGenContext context, AstOperation operation)
-        {
-            return GenerateUnaryFP32(context, operation, context.Delegates.DPdy);
-        }
-
-        private static OperationResult GenerateDiscard(CodeGenContext context, AstOperation operation)
-        {
-            context.Kill();
-            return OperationResult.Invalid;
-        }
-
-        private static OperationResult GenerateDivide(CodeGenContext context, AstOperation operation)
-        {
-            return GenerateBinary(context, operation, context.Delegates.FDiv, context.Delegates.SDiv);
-        }
-
-        private static OperationResult GenerateEmitVertex(CodeGenContext context, AstOperation operation)
-        {
-            context.EmitVertex();
-
-            return OperationResult.Invalid;
-        }
-
-        private static OperationResult GenerateEndPrimitive(CodeGenContext context, AstOperation operation)
-        {
-            context.EndPrimitive();
-
-            return OperationResult.Invalid;
-        }
-
-        private static OperationResult GenerateExponentB2(CodeGenContext context, AstOperation operation)
-        {
-            return GenerateUnary(context, operation, context.Delegates.GlslExp2, null);
-        }
-
-        private static OperationResult GenerateFSIBegin(CodeGenContext context, AstOperation operation)
-        {
-            if (context.Config.GpuAccessor.QueryHostSupportsFragmentShaderInterlock())
-            {
-                context.BeginInvocationInterlockEXT();
-            }
-
-            return OperationResult.Invalid;
-        }
-
-        private static OperationResult GenerateFSIEnd(CodeGenContext context, AstOperation operation)
-        {
-            if (context.Config.GpuAccessor.QueryHostSupportsFragmentShaderInterlock())
-            {
-                context.EndInvocationInterlockEXT();
-            }
-
-            return OperationResult.Invalid;
-        }
-
-        private static OperationResult GenerateFindLSB(CodeGenContext context, AstOperation operation)
-        {
-            var source = context.GetU32(operation.GetSource(0));
-            return new OperationResult(AggregateType.U32, context.GlslFindILsb(context.TypeU32(), source));
-        }
-
-        private static OperationResult GenerateFindMSBS32(CodeGenContext context, AstOperation operation)
-        {
-            var source = context.GetS32(operation.GetSource(0));
-            return new OperationResult(AggregateType.U32, context.GlslFindSMsb(context.TypeU32(), source));
-        }
-
-        private static OperationResult GenerateFindMSBU32(CodeGenContext context, AstOperation operation)
-        {
-            var source = context.GetU32(operation.GetSource(0));
-            return new OperationResult(AggregateType.U32, context.GlslFindUMsb(context.TypeU32(), source));
-        }
-
-        private static OperationResult GenerateFloor(CodeGenContext context, AstOperation operation)
-        {
-            return GenerateUnary(context, operation, context.Delegates.GlslFloor, null);
-        }
-
-        private static OperationResult GenerateFusedMultiplyAdd(CodeGenContext context, AstOperation operation)
-        {
-            return GenerateTernary(context, operation, context.Delegates.GlslFma, null);
-        }
-
-        private static OperationResult GenerateGroupMemoryBarrier(CodeGenContext context, AstOperation operation)
-        {
-            context.MemoryBarrier(context.Constant(context.TypeU32(), Scope.Workgroup), context.Constant(context.TypeU32(), DefaultMemorySemantics));
-            return OperationResult.Invalid;
-        }
-
-        private static OperationResult GenerateImageAtomic(CodeGenContext context, AstOperation operation)
-        {
-            AstTextureOperation texOp = (AstTextureOperation)operation;
-
-            bool isBindless = (texOp.Flags & TextureFlags.Bindless) != 0;
-
-            var componentType = texOp.Format.GetComponentType();
-
-            // TODO: Bindless texture support. For now we just return 0/do nothing.
-            if (isBindless)
-            {
-                return new OperationResult(componentType, componentType switch
-                {
-                    AggregateType.S32 => context.Constant(context.TypeS32(), 0),
-                    AggregateType.U32 => context.Constant(context.TypeU32(), 0u),
-                    _ => context.Constant(context.TypeFP32(), 0f),
-                });
-            }
-
-            bool isArray   = (texOp.Type & SamplerType.Array) != 0;
-            bool isIndexed = (texOp.Type & SamplerType.Indexed) != 0;
-
-            int srcIndex = isBindless ? 1 : 0;
-
-            SpvInstruction Src(AggregateType type)
-            {
-                return context.Get(type, texOp.GetSource(srcIndex++));
-            }
-
-            SpvInstruction index = null;
-
-            if (isIndexed)
-            {
-                index = Src(AggregateType.S32);
-            }
-
-            int coordsCount = texOp.Type.GetDimensions();
-
-            int pCount = coordsCount + (isArray ? 1 : 0);
-
-            SpvInstruction pCoords;
-
-            if (pCount > 1)
-            {
-                SpvInstruction[] elems = new SpvInstruction[pCount];
-
-                for (int i = 0; i < pCount; i++)
-                {
-                    elems[i] = Src(AggregateType.S32);
-                }
-
-                var vectorType = context.TypeVector(context.TypeS32(), pCount);
-                pCoords = context.CompositeConstruct(vectorType, elems);
-            }
-            else
-            {
-                pCoords = Src(AggregateType.S32);
-            }
-
-            SpvInstruction value = Src(componentType);
-
-            (var imageType, var imageVariable) = context.Images[new TextureMeta(texOp.CbufSlot, texOp.Handle, texOp.Format)];
-
-            var image = context.Load(imageType, imageVariable);
-
-            SpvInstruction resultType = context.GetType(componentType);
-            SpvInstruction imagePointerType = context.TypePointer(StorageClass.Image, resultType);
-
-            var pointer = context.ImageTexelPointer(imagePointerType, imageVariable, pCoords, context.Constant(context.TypeU32(), 0));
-            var one = context.Constant(context.TypeU32(), 1);
-            var zero = context.Constant(context.TypeU32(), 0);
-
-            var result = (texOp.Flags & TextureFlags.AtomicMask) switch
-            {
-                TextureFlags.Add        => context.AtomicIAdd(resultType, pointer, one, zero, value),
-                TextureFlags.Minimum    => componentType == AggregateType.S32
-                    ? context.AtomicSMin(resultType, pointer, one, zero, value)
-                    : context.AtomicUMin(resultType, pointer, one, zero, value),
-                TextureFlags.Maximum    => componentType == AggregateType.S32
-                    ? context.AtomicSMax(resultType, pointer, one, zero, value)
-                    : context.AtomicUMax(resultType, pointer, one, zero, value),
-                TextureFlags.Increment  => context.AtomicIIncrement(resultType, pointer, one, zero),
-                TextureFlags.Decrement  => context.AtomicIDecrement(resultType, pointer, one, zero),
-                TextureFlags.BitwiseAnd => context.AtomicAnd(resultType, pointer, one, zero, value),
-                TextureFlags.BitwiseOr  => context.AtomicOr(resultType, pointer, one, zero, value),
-                TextureFlags.BitwiseXor => context.AtomicXor(resultType, pointer, one, zero, value),
-                TextureFlags.Swap       => context.AtomicExchange(resultType, pointer, one, zero, value),
-                TextureFlags.CAS        => context.AtomicCompareExchange(resultType, pointer, one, zero, zero, Src(componentType), value),
-                _                       => context.AtomicIAdd(resultType, pointer, one, zero, value),
-            };
-
-            return new OperationResult(componentType, result);
-        }
-
-        private static OperationResult GenerateImageLoad(CodeGenContext context, AstOperation operation)
-        {
-            AstTextureOperation texOp = (AstTextureOperation)operation;
-
-            bool isBindless = (texOp.Flags & TextureFlags.Bindless) != 0;
-
-            var componentType = texOp.Format.GetComponentType();
-
-            // TODO: Bindless texture support. For now we just return 0/do nothing.
-            if (isBindless)
-            {
-                return GetZeroOperationResult(context, texOp, componentType, isVector: true);
-            }
-
-            bool isArray   = (texOp.Type & SamplerType.Array) != 0;
-            bool isIndexed = (texOp.Type & SamplerType.Indexed) != 0;
-
-            int srcIndex = isBindless ? 1 : 0;
-
-            SpvInstruction Src(AggregateType type)
-            {
-                return context.Get(type, texOp.GetSource(srcIndex++));
-            }
-
-            SpvInstruction index = null;
-
-            if (isIndexed)
-            {
-                index = Src(AggregateType.S32);
-            }
-
-            int coordsCount = texOp.Type.GetDimensions();
-
-            int pCount = coordsCount + (isArray ? 1 : 0);
-
-            SpvInstruction pCoords;
-
-            if (pCount > 1)
-            {
-                SpvInstruction[] elems = new SpvInstruction[pCount];
-
-                for (int i = 0; i < pCount; i++)
-                {
-                    elems[i] = Src(AggregateType.S32);
-                }
-
-                var vectorType = context.TypeVector(context.TypeS32(), pCount);
-                pCoords = context.CompositeConstruct(vectorType, elems);
-            }
-            else
-            {
-                pCoords = Src(AggregateType.S32);
-            }
-
-            pCoords = ScalingHelpers.ApplyScaling(context, texOp, pCoords, intCoords: true, isBindless, isIndexed, isArray, pCount);
-
-            (var imageType, var imageVariable) = context.Images[new TextureMeta(texOp.CbufSlot, texOp.Handle, texOp.Format)];
-
-            var image = context.Load(imageType, imageVariable);
-            var imageComponentType = context.GetType(componentType);
-            var swizzledResultType = texOp.GetVectorType(componentType);
-
-            var texel = context.ImageRead(context.TypeVector(imageComponentType, 4), image, pCoords, ImageOperandsMask.MaskNone);
-            var result = GetSwizzledResult(context, texel, swizzledResultType, texOp.Index);
-
-            return new OperationResult(componentType, result);
-        }
-
-        private static OperationResult GenerateImageStore(CodeGenContext context, AstOperation operation)
-        {
-            AstTextureOperation texOp = (AstTextureOperation)operation;
-
-            bool isBindless = (texOp.Flags & TextureFlags.Bindless) != 0;
-
-            // TODO: Bindless texture support. For now we just return 0/do nothing.
-            if (isBindless)
-            {
-                return OperationResult.Invalid;
-            }
-
-            bool isArray   = (texOp.Type & SamplerType.Array)   != 0;
-            bool isIndexed = (texOp.Type & SamplerType.Indexed) != 0;
-
-            int srcIndex = isBindless ? 1 : 0;
-
-            SpvInstruction Src(AggregateType type)
-            {
-                return context.Get(type, texOp.GetSource(srcIndex++));
-            }
-
-            SpvInstruction index = null;
-
-            if (isIndexed)
-            {
-                index = Src(AggregateType.S32);
-            }
-
-            int coordsCount = texOp.Type.GetDimensions();
-
-            int pCount = coordsCount + (isArray ? 1 : 0);
-
-            SpvInstruction pCoords;
-
-            if (pCount > 1)
-            {
-                SpvInstruction[] elems = new SpvInstruction[pCount];
-
-                for (int i = 0; i < pCount; i++)
-                {
-                    elems[i] = Src(AggregateType.S32);
-                }
-
-                var vectorType = context.TypeVector(context.TypeS32(), pCount);
-                pCoords = context.CompositeConstruct(vectorType, elems);
-            }
-            else
-            {
-                pCoords = Src(AggregateType.S32);
-            }
-
-            var componentType = texOp.Format.GetComponentType();
-
-            const int ComponentsCount = 4;
-
-            SpvInstruction[] cElems = new SpvInstruction[ComponentsCount];
-
-            for (int i = 0; i < ComponentsCount; i++)
-            {
-                if (srcIndex < texOp.SourcesCount)
-                {
-                    cElems[i] = Src(componentType);
-                }
-                else
-                {
-                    cElems[i] = componentType switch
-                    {
-                        AggregateType.S32 => context.Constant(context.TypeS32(), 0),
-                        AggregateType.U32 => context.Constant(context.TypeU32(), 0u),
-                        _ => context.Constant(context.TypeFP32(), 0f),
-                    };
-                }
-            }
-
-            var texel = context.CompositeConstruct(context.TypeVector(context.GetType(componentType), ComponentsCount), cElems);
-
-            (var imageType, var imageVariable) = context.Images[new TextureMeta(texOp.CbufSlot, texOp.Handle, texOp.Format)];
-
-            var image = context.Load(imageType, imageVariable);
-
-            context.ImageWrite(image, pCoords, texel, ImageOperandsMask.MaskNone);
-
-            return OperationResult.Invalid;
-        }
-
-        private static OperationResult GenerateIsNan(CodeGenContext context, AstOperation operation)
-        {
-            var source = operation.GetSource(0);
-
-            SpvInstruction result;
-
-            if (operation.Inst.HasFlag(Instruction.FP64))
-            {
-                result = context.IsNan(context.TypeBool(), context.GetFP64(source));
-            }
-            else
-            {
-                result = context.IsNan(context.TypeBool(), context.GetFP32(source));
-            }
-
-            return new OperationResult(AggregateType.Bool, result);
-        }
-
-        private static OperationResult GenerateLoad(CodeGenContext context, AstOperation operation)
-        {
-            return GenerateLoadOrStore(context, operation, isStore: false);
-        }
-
-        private static OperationResult GenerateLoadConstant(CodeGenContext context, AstOperation operation)
-        {
-            var src1 = operation.GetSource(0);
-            var src2 = context.Get(AggregateType.S32, operation.GetSource(1));
-
-            var i1 = context.Constant(context.TypeS32(), 0);
-            var i2 = context.ShiftRightArithmetic(context.TypeS32(), src2, context.Constant(context.TypeS32(), 2));
-            var i3 = context.BitwiseAnd(context.TypeS32(), src2, context.Constant(context.TypeS32(), 3));
-
-            SpvInstruction value = null;
-
-            if (context.Config.GpuAccessor.QueryHostHasVectorIndexingBug())
-            {
-                // Test for each component individually.
-                for (int i = 0; i < 4; i++)
-                {
-                    var component = context.Constant(context.TypeS32(), i);
-
-                    SpvInstruction elemPointer;
-                    if (context.UniformBuffersArray != null)
-                    {
-                        var ubVariable = context.UniformBuffersArray;
-                        var i0 = context.Get(AggregateType.S32, src1);
-
-                        elemPointer = context.AccessChain(context.TypePointer(StorageClass.Uniform, context.TypeFP32()), ubVariable, i0, i1, i2, component);
-                    }
-                    else
-                    {
-                        var ubVariable = context.UniformBuffers[((AstOperand)src1).Value];
-
-                        elemPointer = context.AccessChain(context.TypePointer(StorageClass.Uniform, context.TypeFP32()), ubVariable, i1, i2, component);
-                    }
-
-                    SpvInstruction newValue = context.Load(context.TypeFP32(), elemPointer);
-
-                    value = value != null ? context.Select(context.TypeFP32(), context.IEqual(context.TypeBool(), i3, component), newValue, value) : newValue;
-                }
-            }
-            else
-            {
-                SpvInstruction elemPointer;
-
-                if (context.UniformBuffersArray != null)
-                {
-                    var ubVariable = context.UniformBuffersArray;
-                    var i0 = context.Get(AggregateType.S32, src1);
-
-                    elemPointer = context.AccessChain(context.TypePointer(StorageClass.Uniform, context.TypeFP32()), ubVariable, i0, i1, i2, i3);
-                }
-                else
-                {
-                    var ubVariable = context.UniformBuffers[((AstOperand)src1).Value];
-
-                    elemPointer = context.AccessChain(context.TypePointer(StorageClass.Uniform, context.TypeFP32()), ubVariable, i1, i2, i3);
-                }
-
-                value = context.Load(context.TypeFP32(), elemPointer);
-            }
-
-            return new OperationResult(AggregateType.FP32, value);
-        }
-
-        private static OperationResult GenerateLoadLocal(CodeGenContext context, AstOperation operation)
-        {
-            return GenerateLoadLocalOrShared(context, operation, StorageClass.Private, context.LocalMemory);
-        }
-
-        private static OperationResult GenerateLoadShared(CodeGenContext context, AstOperation operation)
-        {
-            return GenerateLoadLocalOrShared(context, operation, StorageClass.Workgroup, context.SharedMemory);
-        }
-
-        private static OperationResult GenerateLoadLocalOrShared(
-            CodeGenContext context,
-            AstOperation operation,
-            StorageClass storageClass,
-            SpvInstruction memory)
-        {
-            var offset = context.Get(AggregateType.S32, operation.GetSource(0));
-
-            var elemPointer = context.AccessChain(context.TypePointer(storageClass, context.TypeU32()), memory, offset);
-            var value = context.Load(context.TypeU32(), elemPointer);
-
-            return new OperationResult(AggregateType.U32, value);
-        }
-
-        private static OperationResult GenerateLoadStorage(CodeGenContext context, AstOperation operation)
-        {
-            var elemPointer = GetStorageElemPointer(context, operation);
-            var value = context.Load(context.TypeU32(), elemPointer);
-
-            return new OperationResult(AggregateType.U32, value);
-        }
-
-        private static OperationResult GenerateLod(CodeGenContext context, AstOperation operation)
-        {
-            AstTextureOperation texOp = (AstTextureOperation)operation;
-
-            bool isBindless = (texOp.Flags & TextureFlags.Bindless) != 0;
-
-            bool isIndexed = (texOp.Type & SamplerType.Indexed) != 0;
-
-            // TODO: Bindless texture support. For now we just return 0.
-            if (isBindless)
-            {
-                return new OperationResult(AggregateType.S32, context.Constant(context.TypeS32(), 0));
-            }
-
-            int srcIndex = 0;
-
-            SpvInstruction Src(AggregateType type)
-            {
-                return context.Get(type, texOp.GetSource(srcIndex++));
-            }
-
-            SpvInstruction index = null;
-
-            if (isIndexed)
-            {
-                index = Src(AggregateType.S32);
-            }
-
-            int pCount = texOp.Type.GetDimensions();
-
-            SpvInstruction pCoords;
-
-            if (pCount > 1)
-            {
-                SpvInstruction[] elems = new SpvInstruction[pCount];
-
-                for (int i = 0; i < pCount; i++)
-                {
-                    elems[i] = Src(AggregateType.FP32);
-                }
-
-                var vectorType = context.TypeVector(context.TypeFP32(), pCount);
-                pCoords = context.CompositeConstruct(vectorType, elems);
-            }
-            else
-            {
-                pCoords = Src(AggregateType.FP32);
-            }
-
-            var meta = new TextureMeta(texOp.CbufSlot, texOp.Handle, texOp.Format);
-
-            (_, var sampledImageType, var sampledImageVariable) = context.Samplers[meta];
-
-            var image = context.Load(sampledImageType, sampledImageVariable);
-
-            var resultType = context.TypeVector(context.TypeFP32(), 2);
-            var packed = context.ImageQueryLod(resultType, image, pCoords);
-            var result = context.CompositeExtract(context.TypeFP32(), packed, (SpvLiteralInteger)texOp.Index);
-
-            return new OperationResult(AggregateType.FP32, result);
-        }
-
-        private static OperationResult GenerateLogarithmB2(CodeGenContext context, AstOperation operation)
-        {
-            return GenerateUnary(context, operation, context.Delegates.GlslLog2, null);
-        }
-
-        private static OperationResult GenerateLogicalAnd(CodeGenContext context, AstOperation operation)
-        {
-            return GenerateBinaryBool(context, operation, context.Delegates.LogicalAnd);
-        }
-
-        private static OperationResult GenerateLogicalExclusiveOr(CodeGenContext context, AstOperation operation)
-        {
-            return GenerateBinaryBool(context, operation, context.Delegates.LogicalNotEqual);
-        }
-
-        private static OperationResult GenerateLogicalNot(CodeGenContext context, AstOperation operation)
-        {
-            return GenerateUnaryBool(context, operation, context.Delegates.LogicalNot);
-        }
-
-        private static OperationResult GenerateLogicalOr(CodeGenContext context, AstOperation operation)
-        {
-            return GenerateBinaryBool(context, operation, context.Delegates.LogicalOr);
-        }
-
-        private static OperationResult GenerateLoopBreak(CodeGenContext context, AstOperation operation)
-        {
-            AstBlock loopBlock = context.CurrentBlock;
-            while (loopBlock.Type != AstBlockType.DoWhile)
-            {
-                loopBlock = loopBlock.Parent;
-            }
-
-            context.Branch(context.GetNextLabel(loopBlock.Parent));
-
-            return OperationResult.Invalid;
-        }
-
-        private static OperationResult GenerateLoopContinue(CodeGenContext context, AstOperation operation)
-        {
-            AstBlock loopBlock = context.CurrentBlock;
-            while (loopBlock.Type != AstBlockType.DoWhile)
-            {
-                loopBlock = loopBlock.Parent;
-            }
-
-            (var loopTarget, var continueTarget) = context.LoopTargets[loopBlock];
-
-            context.Branch(continueTarget);
-
-            return OperationResult.Invalid;
-        }
-
-        private static OperationResult GenerateMaximum(CodeGenContext context, AstOperation operation)
-        {
-            return GenerateBinary(context, operation, context.Delegates.GlslFMax, context.Delegates.GlslSMax);
-        }
-
-        private static OperationResult GenerateMaximumU32(CodeGenContext context, AstOperation operation)
-        {
-            return GenerateBinaryU32(context, operation, context.Delegates.GlslUMax);
-        }
-
-        private static OperationResult GenerateMemoryBarrier(CodeGenContext context, AstOperation operation)
-        {
-            context.MemoryBarrier(context.Constant(context.TypeU32(), Scope.Device), context.Constant(context.TypeU32(), DefaultMemorySemantics));
-            return OperationResult.Invalid;
-        }
-
-        private static OperationResult GenerateMinimum(CodeGenContext context, AstOperation operation)
-        {
-            return GenerateBinary(context, operation, context.Delegates.GlslFMin, context.Delegates.GlslSMin);
-        }
-
-        private static OperationResult GenerateMinimumU32(CodeGenContext context, AstOperation operation)
-        {
-            return GenerateBinaryU32(context, operation, context.Delegates.GlslUMin);
-        }
-
-        private static OperationResult GenerateMultiply(CodeGenContext context, AstOperation operation)
-        {
-            return GenerateBinary(context, operation, context.Delegates.FMul, context.Delegates.IMul);
-        }
-
-        private static OperationResult GenerateMultiplyHighS32(CodeGenContext context, AstOperation operation)
-        {
-            var src1 = operation.GetSource(0);
-            var src2 = operation.GetSource(1);
-
-            var resultType = context.TypeStruct(false, context.TypeS32(), context.TypeS32());
-            var result = context.SMulExtended(resultType, context.GetS32(src1), context.GetS32(src2));
-            result = context.CompositeExtract(context.TypeS32(), result, 1);
-
-            return new OperationResult(AggregateType.S32, result);
-        }
-
-        private static OperationResult GenerateMultiplyHighU32(CodeGenContext context, AstOperation operation)
-        {
-            var src1 = operation.GetSource(0);
-            var src2 = operation.GetSource(1);
-
-            var resultType = context.TypeStruct(false, context.TypeU32(), context.TypeU32());
-            var result = context.UMulExtended(resultType, context.GetU32(src1), context.GetU32(src2));
-            result = context.CompositeExtract(context.TypeU32(), result, 1);
-
-            return new OperationResult(AggregateType.U32, result);
-        }
-
-        private static OperationResult GenerateNegate(CodeGenContext context, AstOperation operation)
-        {
-            return GenerateUnary(context, operation, context.Delegates.FNegate, context.Delegates.SNegate);
-        }
-
-        private static OperationResult GeneratePackDouble2x32(CodeGenContext context, AstOperation operation)
-        {
-            var value0 = context.GetU32(operation.GetSource(0));
-            var value1 = context.GetU32(operation.GetSource(1));
-            var vector = context.CompositeConstruct(context.TypeVector(context.TypeU32(), 2), value0, value1);
-            var result = context.GlslPackDouble2x32(context.TypeFP64(), vector);
-
-            return new OperationResult(AggregateType.FP64, result);
-        }
-
-        private static OperationResult GeneratePackHalf2x16(CodeGenContext context, AstOperation operation)
-        {
-            var value0 = context.GetFP32(operation.GetSource(0));
-            var value1 = context.GetFP32(operation.GetSource(1));
-            var vector = context.CompositeConstruct(context.TypeVector(context.TypeFP32(), 2), value0, value1);
-            var result = context.GlslPackHalf2x16(context.TypeU32(), vector);
-
-            return new OperationResult(AggregateType.U32, result);
-        }
-
-        private static OperationResult GenerateReciprocalSquareRoot(CodeGenContext context, AstOperation operation)
-        {
-            return GenerateUnary(context, operation, context.Delegates.GlslInverseSqrt, null);
-        }
-
-        private static OperationResult GenerateReturn(CodeGenContext context, AstOperation operation)
-        {
-            context.Return();
-            return OperationResult.Invalid;
-        }
-
-        private static OperationResult GenerateRound(CodeGenContext context, AstOperation operation)
-        {
-            return GenerateUnary(context, operation, context.Delegates.GlslRoundEven, null);
-        }
-
-        private static OperationResult GenerateShiftLeft(CodeGenContext context, AstOperation operation)
-        {
-            return GenerateBinaryS32(context, operation, context.Delegates.ShiftLeftLogical);
-        }
-
-        private static OperationResult GenerateShiftRightS32(CodeGenContext context, AstOperation operation)
-        {
-            return GenerateBinaryS32(context, operation, context.Delegates.ShiftRightArithmetic);
-        }
-
-        private static OperationResult GenerateShiftRightU32(CodeGenContext context, AstOperation operation)
-        {
-            return GenerateBinaryS32(context, operation, context.Delegates.ShiftRightLogical);
-        }
-
-        private static OperationResult GenerateShuffle(CodeGenContext context, AstOperation operation)
-        {
-            var x = context.GetFP32(operation.GetSource(0));
-            var index = context.GetU32(operation.GetSource(1));
-            var mask = context.GetU32(operation.GetSource(2));
-
-            var const31 = context.Constant(context.TypeU32(), 31);
-            var const8 = context.Constant(context.TypeU32(), 8);
-
-            var clamp = context.BitwiseAnd(context.TypeU32(), mask, const31);
-            var segMask = context.BitwiseAnd(context.TypeU32(), context.ShiftRightLogical(context.TypeU32(), mask, const8), const31);
-            var notSegMask = context.Not(context.TypeU32(), segMask);
-            var clampNotSegMask = context.BitwiseAnd(context.TypeU32(), clamp, notSegMask);
-            var indexNotSegMask = context.BitwiseAnd(context.TypeU32(), index, notSegMask);
-
-            var threadId = GetScalarInput(context, IoVariable.SubgroupLaneId);
-
-            var minThreadId = context.BitwiseAnd(context.TypeU32(), threadId, segMask);
-            var maxThreadId = context.BitwiseOr(context.TypeU32(), minThreadId, clampNotSegMask);
-            var srcThreadId = context.BitwiseOr(context.TypeU32(), indexNotSegMask, minThreadId);
-            var valid = context.ULessThanEqual(context.TypeBool(), srcThreadId, maxThreadId);
-            var value = context.GroupNonUniformShuffle(context.TypeFP32(), context.Constant(context.TypeU32(), (int)Scope.Subgroup), x, srcThreadId);
-            var result = context.Select(context.TypeFP32(), valid, value, x);
-
-            var validLocal = (AstOperand)operation.GetSource(3);
-
-            context.Store(context.GetLocalPointer(validLocal), context.BitcastIfNeeded(validLocal.VarType, AggregateType.Bool, valid));
-
-            return new OperationResult(AggregateType.FP32, result);
-        }
-
-        private static OperationResult GenerateShuffleDown(CodeGenContext context, AstOperation operation)
-        {
-            var x = context.GetFP32(operation.GetSource(0));
-            var index = context.GetU32(operation.GetSource(1));
-            var mask = context.GetU32(operation.GetSource(2));
-
-            var const31 = context.Constant(context.TypeU32(), 31);
-            var const8 = context.Constant(context.TypeU32(), 8);
-
-            var clamp = context.BitwiseAnd(context.TypeU32(), mask, const31);
-            var segMask = context.BitwiseAnd(context.TypeU32(), context.ShiftRightLogical(context.TypeU32(), mask, const8), const31);
-            var notSegMask = context.Not(context.TypeU32(), segMask);
-            var clampNotSegMask = context.BitwiseAnd(context.TypeU32(), clamp, notSegMask);
-
-            var threadId = GetScalarInput(context, IoVariable.SubgroupLaneId);
-
-            var minThreadId = context.BitwiseAnd(context.TypeU32(), threadId, segMask);
-            var maxThreadId = context.BitwiseOr(context.TypeU32(), minThreadId, clampNotSegMask);
-            var srcThreadId = context.IAdd(context.TypeU32(), threadId, index);
-            var valid = context.ULessThanEqual(context.TypeBool(), srcThreadId, maxThreadId);
-            var value = context.GroupNonUniformShuffle(context.TypeFP32(), context.Constant(context.TypeU32(), (int)Scope.Subgroup), x, srcThreadId);
-            var result = context.Select(context.TypeFP32(), valid, value, x);
-
-            var validLocal = (AstOperand)operation.GetSource(3);
-
-            context.Store(context.GetLocalPointer(validLocal), context.BitcastIfNeeded(validLocal.VarType, AggregateType.Bool, valid));
-
-            return new OperationResult(AggregateType.FP32, result);
-        }
-
-        private static OperationResult GenerateShuffleUp(CodeGenContext context, AstOperation operation)
-        {
-            var x = context.GetFP32(operation.GetSource(0));
-            var index = context.GetU32(operation.GetSource(1));
-            var mask = context.GetU32(operation.GetSource(2));
-
-            var const31 = context.Constant(context.TypeU32(), 31);
-            var const8 = context.Constant(context.TypeU32(), 8);
-
-            var segMask = context.BitwiseAnd(context.TypeU32(), context.ShiftRightLogical(context.TypeU32(), mask, const8), const31);
-
-            var threadId = GetScalarInput(context, IoVariable.SubgroupLaneId);
-
-            var minThreadId = context.BitwiseAnd(context.TypeU32(), threadId, segMask);
-            var srcThreadId = context.ISub(context.TypeU32(), threadId, index);
-            var valid = context.SGreaterThanEqual(context.TypeBool(), srcThreadId, minThreadId);
-            var value = context.GroupNonUniformShuffle(context.TypeFP32(), context.Constant(context.TypeU32(), (int)Scope.Subgroup), x, srcThreadId);
-            var result = context.Select(context.TypeFP32(), valid, value, x);
-
-            var validLocal = (AstOperand)operation.GetSource(3);
-
-            context.Store(context.GetLocalPointer(validLocal), context.BitcastIfNeeded(validLocal.VarType, AggregateType.Bool, valid));
-
-            return new OperationResult(AggregateType.FP32, result);
-        }
-
-        private static OperationResult GenerateShuffleXor(CodeGenContext context, AstOperation operation)
-        {
-            var x = context.GetFP32(operation.GetSource(0));
-            var index = context.GetU32(operation.GetSource(1));
-            var mask = context.GetU32(operation.GetSource(2));
-
-            var const31 = context.Constant(context.TypeU32(), 31);
-            var const8 = context.Constant(context.TypeU32(), 8);
-
-            var clamp = context.BitwiseAnd(context.TypeU32(), mask, const31);
-            var segMask = context.BitwiseAnd(context.TypeU32(), context.ShiftRightLogical(context.TypeU32(), mask, const8), const31);
-            var notSegMask = context.Not(context.TypeU32(), segMask);
-            var clampNotSegMask = context.BitwiseAnd(context.TypeU32(), clamp, notSegMask);
-
-            var threadId = GetScalarInput(context, IoVariable.SubgroupLaneId);
-
-            var minThreadId = context.BitwiseAnd(context.TypeU32(), threadId, segMask);
-            var maxThreadId = context.BitwiseOr(context.TypeU32(), minThreadId, clampNotSegMask);
-            var srcThreadId = context.BitwiseXor(context.TypeU32(), threadId, index);
-            var valid = context.ULessThanEqual(context.TypeBool(), srcThreadId, maxThreadId);
-            var value = context.GroupNonUniformShuffle(context.TypeFP32(), context.Constant(context.TypeU32(), (int)Scope.Subgroup), x, srcThreadId);
-            var result = context.Select(context.TypeFP32(), valid, value, x);
-
-            var validLocal = (AstOperand)operation.GetSource(3);
-
-            context.Store(context.GetLocalPointer(validLocal), context.BitcastIfNeeded(validLocal.VarType, AggregateType.Bool, valid));
-
-            return new OperationResult(AggregateType.FP32, result);
-        }
-
-        private static OperationResult GenerateSine(CodeGenContext context, AstOperation operation)
-        {
-            return GenerateUnary(context, operation, context.Delegates.GlslSin, null);
-        }
-
-        private static OperationResult GenerateSquareRoot(CodeGenContext context, AstOperation operation)
-        {
-            return GenerateUnary(context, operation, context.Delegates.GlslSqrt, null);
-        }
-
-        private static OperationResult GenerateStore(CodeGenContext context, AstOperation operation)
-        {
-            return GenerateLoadOrStore(context, operation, isStore: true);
-        }
-
-        private static OperationResult GenerateStoreLocal(CodeGenContext context, AstOperation operation)
-        {
-            return GenerateStoreLocalOrShared(context, operation, StorageClass.Private, context.LocalMemory);
-        }
-
-        private static OperationResult GenerateStoreShared(CodeGenContext context, AstOperation operation)
-        {
-            return GenerateStoreLocalOrShared(context, operation, StorageClass.Workgroup, context.SharedMemory);
-        }
-
-        private static OperationResult GenerateStoreLocalOrShared(
-            CodeGenContext context,
-            AstOperation operation,
-            StorageClass storageClass,
-            SpvInstruction memory)
-        {
-            var offset = context.Get(AggregateType.S32, operation.GetSource(0));
-            var value = context.Get(AggregateType.U32, operation.GetSource(1));
-
-            var elemPointer = context.AccessChain(context.TypePointer(storageClass, context.TypeU32()), memory, offset);
-            context.Store(elemPointer, value);
-
-            return OperationResult.Invalid;
-        }
-
-        private static OperationResult GenerateStoreShared16(CodeGenContext context, AstOperation operation)
-        {
-            GenerateStoreSharedSmallInt(context, operation, 16);
-
-            return OperationResult.Invalid;
-        }
-
-        private static OperationResult GenerateStoreShared8(CodeGenContext context, AstOperation operation)
-        {
-            GenerateStoreSharedSmallInt(context, operation, 8);
-
-            return OperationResult.Invalid;
-        }
-
-        private static OperationResult GenerateStoreStorage(CodeGenContext context, AstOperation operation)
-        {
-            var elemPointer = GetStorageElemPointer(context, operation);
-            context.Store(elemPointer, context.Get(AggregateType.U32, operation.GetSource(2)));
-
-            return OperationResult.Invalid;
-        }
-
-        private static OperationResult GenerateStoreStorage16(CodeGenContext context, AstOperation operation)
-        {
-            GenerateStoreStorageSmallInt(context, operation, 16);
-
-            return OperationResult.Invalid;
-        }
-
-        private static OperationResult GenerateStoreStorage8(CodeGenContext context, AstOperation operation)
-        {
-            GenerateStoreStorageSmallInt(context, operation, 8);
-
-            return OperationResult.Invalid;
-        }
-
-        private static OperationResult GenerateSubtract(CodeGenContext context, AstOperation operation)
-        {
-            return GenerateBinary(context, operation, context.Delegates.FSub, context.Delegates.ISub);
-        }
-
-        private static OperationResult GenerateSwizzleAdd(CodeGenContext context, AstOperation operation)
-        {
-            var x = context.Get(AggregateType.FP32, operation.GetSource(0));
-            var y = context.Get(AggregateType.FP32, operation.GetSource(1));
-            var mask = context.Get(AggregateType.U32, operation.GetSource(2));
-
-            var v4float = context.TypeVector(context.TypeFP32(), 4);
-            var one = context.Constant(context.TypeFP32(), 1.0f);
-            var minusOne = context.Constant(context.TypeFP32(), -1.0f);
-            var zero = context.Constant(context.TypeFP32(), 0.0f);
-            var xLut = context.ConstantComposite(v4float, one, minusOne, one, zero);
-            var yLut = context.ConstantComposite(v4float, one, one, minusOne, one);
-
-            var three = context.Constant(context.TypeU32(), 3);
-
-            var threadId = GetScalarInput(context, IoVariable.SubgroupLaneId);
-            var shift = context.BitwiseAnd(context.TypeU32(), threadId, three);
-            shift = context.ShiftLeftLogical(context.TypeU32(), shift, context.Constant(context.TypeU32(), 1));
-            var lutIdx = context.ShiftRightLogical(context.TypeU32(), mask, shift);
-            lutIdx = context.BitwiseAnd(context.TypeU32(), lutIdx, three);
-
-            var xLutValue = context.VectorExtractDynamic(context.TypeFP32(), xLut, lutIdx);
-            var yLutValue = context.VectorExtractDynamic(context.TypeFP32(), yLut, lutIdx);
-
-            var xResult = context.FMul(context.TypeFP32(), x, xLutValue);
-            var yResult = context.FMul(context.TypeFP32(), y, yLutValue);
-            var result = context.FAdd(context.TypeFP32(), xResult, yResult);
-
-            return new OperationResult(AggregateType.FP32, result);
-        }
-
-        private static OperationResult GenerateTextureSample(CodeGenContext context, AstOperation operation)
-        {
-            AstTextureOperation texOp = (AstTextureOperation)operation;
-
-            bool isBindless     = (texOp.Flags & TextureFlags.Bindless)    != 0;
-            bool isGather       = (texOp.Flags & TextureFlags.Gather)      != 0;
-            bool hasDerivatives = (texOp.Flags & TextureFlags.Derivatives) != 0;
-            bool intCoords      = (texOp.Flags & TextureFlags.IntCoords)   != 0;
-            bool hasLodBias     = (texOp.Flags & TextureFlags.LodBias)     != 0;
-            bool hasLodLevel    = (texOp.Flags & TextureFlags.LodLevel)    != 0;
-            bool hasOffset      = (texOp.Flags & TextureFlags.Offset)      != 0;
-            bool hasOffsets     = (texOp.Flags & TextureFlags.Offsets)     != 0;
-
-            bool isArray       = (texOp.Type & SamplerType.Array)       != 0;
-            bool isIndexed     = (texOp.Type & SamplerType.Indexed)     != 0;
-            bool isMultisample = (texOp.Type & SamplerType.Multisample) != 0;
-            bool isShadow      = (texOp.Type & SamplerType.Shadow)      != 0;
-
-            bool colorIsVector = isGather || !isShadow;
-
-            // TODO: Bindless texture support. For now we just return 0.
-            if (isBindless)
-            {
-                return GetZeroOperationResult(context, texOp, AggregateType.FP32, colorIsVector);
-            }
-
-            // This combination is valid, but not available on GLSL.
-            // For now, ignore the LOD level and do a normal sample.
-            // TODO: How to implement it properly?
-            if (hasLodLevel && isArray && isShadow)
-            {
-                hasLodLevel = false;
-            }
-
-            int srcIndex = isBindless ? 1 : 0;
-
-            SpvInstruction Src(AggregateType type)
-            {
-                return context.Get(type, texOp.GetSource(srcIndex++));
-            }
-
-            SpvInstruction index = null;
-
-            if (isIndexed)
-            {
-                index = Src(AggregateType.S32);
-            }
-
-            int coordsCount = texOp.Type.GetDimensions();
-
-            int pCount = coordsCount;
-
-            int arrayIndexElem = -1;
-
-            if (isArray)
-            {
-                arrayIndexElem = pCount++;
-            }
-
-            AggregateType coordType = intCoords ? AggregateType.S32 : AggregateType.FP32;
-
-            SpvInstruction AssemblePVector(int count)
-            {
-                if (count > 1)
-                {
-                    SpvInstruction[] elems = new SpvInstruction[count];
-
-                    for (int index = 0; index < count; index++)
-                    {
-                        if (arrayIndexElem == index)
-                        {
-                            elems[index] = Src(AggregateType.S32);
-
-                            if (!intCoords)
-                            {
-                                elems[index] = context.ConvertSToF(context.TypeFP32(), elems[index]);
-                            }
-                        }
-                        else
-                        {
-                            elems[index] = Src(coordType);
-                        }
-                    }
-
-                    var vectorType = context.TypeVector(intCoords ? context.TypeS32() : context.TypeFP32(), count);
-                    return context.CompositeConstruct(vectorType, elems);
-                }
-                else
-                {
-                    return Src(coordType);
-                }
-            }
-
-            SpvInstruction ApplyBias(SpvInstruction vector, SpvInstruction image)
-            {
-                int gatherBiasPrecision = context.Config.GpuAccessor.QueryHostGatherBiasPrecision();
-                if (isGather && gatherBiasPrecision != 0)
-                {
-                    // GPU requires texture gather to be slightly offset to match NVIDIA behaviour when point is exactly between two texels.
-                    // Offset by the gather precision divided by 2 to correct for rounding.
-                    var sizeType = pCount == 1 ? context.TypeS32() : context.TypeVector(context.TypeS32(), pCount);
-                    var pVectorType = pCount == 1 ? context.TypeFP32() : context.TypeVector(context.TypeFP32(), pCount);
-
-                    var bias = context.Constant(context.TypeFP32(), (float)(1 << (gatherBiasPrecision + 1)));
-                    var biasVector = context.CompositeConstruct(pVectorType, Enumerable.Repeat(bias, pCount).ToArray());
-
-                    var one = context.Constant(context.TypeFP32(), 1f);
-                    var oneVector = context.CompositeConstruct(pVectorType, Enumerable.Repeat(one, pCount).ToArray());
-
-                    var divisor = context.FMul(
-                        pVectorType,
-                        context.ConvertSToF(pVectorType, context.ImageQuerySize(sizeType, image)),
-                        biasVector);
-
-                    vector = context.FAdd(pVectorType, vector, context.FDiv(pVectorType, oneVector, divisor));
-                }
-
-                return vector;
-            }
-
-            SpvInstruction pCoords = AssemblePVector(pCount);
-            pCoords = ScalingHelpers.ApplyScaling(context, texOp, pCoords, intCoords, isBindless, isIndexed, isArray, pCount);
-
-            SpvInstruction AssembleDerivativesVector(int count)
-            {
-                if (count > 1)
-                {
-                    SpvInstruction[] elems = new SpvInstruction[count];
-
-                    for (int index = 0; index < count; index++)
-                    {
-                        elems[index] = Src(AggregateType.FP32);
-                    }
-
-                    var vectorType = context.TypeVector(context.TypeFP32(), count);
-                    return context.CompositeConstruct(vectorType, elems);
-                }
-                else
-                {
-                    return Src(AggregateType.FP32);
-                }
-            }
-
-            SpvInstruction dRef = null;
-
-            if (isShadow)
-            {
-                dRef = Src(AggregateType.FP32);
-            }
-
-            SpvInstruction[] derivatives = null;
-
-            if (hasDerivatives)
-            {
-                derivatives = new[]
-                {
-                    AssembleDerivativesVector(coordsCount), // dPdx
-                    AssembleDerivativesVector(coordsCount)  // dPdy
-                };
-            }
-
-            SpvInstruction sample = null;
-            SpvInstruction lod = null;
-
-            if (isMultisample)
-            {
-                sample = Src(AggregateType.S32);
-            }
-            else if (hasLodLevel)
-            {
-                lod = Src(coordType);
-            }
-
-            SpvInstruction AssembleOffsetVector(int count)
-            {
-                if (count > 1)
-                {
-                    SpvInstruction[] elems = new SpvInstruction[count];
-
-                    for (int index = 0; index < count; index++)
-                    {
-                        elems[index] = Src(AggregateType.S32);
-                    }
-
-                    var vectorType = context.TypeVector(context.TypeS32(), count);
-
-                    return context.ConstantComposite(vectorType, elems);
-                }
-                else
-                {
-                    return Src(AggregateType.S32);
-                }
-            }
-
-            SpvInstruction[] offsets = null;
-
-            if (hasOffset)
-            {
-                offsets = new[] { AssembleOffsetVector(coordsCount) };
-            }
-            else if (hasOffsets)
-            {
-                offsets = new[]
-                {
-                    AssembleOffsetVector(coordsCount),
-                    AssembleOffsetVector(coordsCount),
-                    AssembleOffsetVector(coordsCount),
-                    AssembleOffsetVector(coordsCount)
-                };
-            }
-
-            SpvInstruction lodBias = null;
-
-            if (hasLodBias)
-            {
-               lodBias = Src(AggregateType.FP32);
-            }
-
-            SpvInstruction compIdx = null;
-
-            // textureGather* optional extra component index,
-            // not needed for shadow samplers.
-            if (isGather && !isShadow)
-            {
-               compIdx = Src(AggregateType.S32);
-            }
-
-            var operandsList = new List<SpvInstruction>();
-            var operandsMask = ImageOperandsMask.MaskNone;
-
-            if (hasLodBias)
-            {
-                operandsMask |= ImageOperandsMask.Bias;
-                operandsList.Add(lodBias);
-            }
-
-            if (!isMultisample && hasLodLevel)
-            {
-                operandsMask |= ImageOperandsMask.Lod;
-                operandsList.Add(lod);
-            }
-
-            if (hasDerivatives)
-            {
-                operandsMask |= ImageOperandsMask.Grad;
-                operandsList.Add(derivatives[0]);
-                operandsList.Add(derivatives[1]);
-            }
-
-            if (hasOffset)
-            {
-                operandsMask |= ImageOperandsMask.ConstOffset;
-                operandsList.Add(offsets[0]);
-            }
-            else if (hasOffsets)
-            {
-                operandsMask |= ImageOperandsMask.ConstOffsets;
-                SpvInstruction arrayv2 = context.TypeArray(context.TypeVector(context.TypeS32(), 2), context.Constant(context.TypeU32(), 4));
-                operandsList.Add(context.ConstantComposite(arrayv2, offsets[0], offsets[1], offsets[2], offsets[3]));
-            }
-
-            if (isMultisample)
-            {
-                operandsMask |= ImageOperandsMask.Sample;
-                operandsList.Add(sample);
-            }
-
-            var resultType = colorIsVector ? context.TypeVector(context.TypeFP32(), 4) : context.TypeFP32();
-
-            var meta = new TextureMeta(texOp.CbufSlot, texOp.Handle, texOp.Format);
-
-            (var imageType, var sampledImageType, var sampledImageVariable) = context.Samplers[meta];
-
-            var image = context.Load(sampledImageType, sampledImageVariable);
-
-            if (intCoords)
-            {
-                image = context.Image(imageType, image);
-            }
-
-            pCoords = ApplyBias(pCoords, image);
-
-            var operands = operandsList.ToArray();
-
-            SpvInstruction result;
-
-            if (intCoords)
-            {
-                result = context.ImageFetch(resultType, image, pCoords, operandsMask, operands);
-            }
-            else if (isGather)
-            {
-                if (isShadow)
-                {
-                    result = context.ImageDrefGather(resultType, image, pCoords, dRef, operandsMask, operands);
-                }
-                else
-                {
-                    result = context.ImageGather(resultType, image, pCoords, compIdx, operandsMask, operands);
-                }
-            }
-            else if (isShadow)
-            {
-                if (hasLodLevel)
-                {
-                    result = context.ImageSampleDrefExplicitLod(resultType, image, pCoords, dRef, operandsMask, operands);
-                }
-                else
-                {
-                    result = context.ImageSampleDrefImplicitLod(resultType, image, pCoords, dRef, operandsMask, operands);
-                }
-            }
-            else if (hasDerivatives || hasLodLevel)
-            {
-                result = context.ImageSampleExplicitLod(resultType, image, pCoords, operandsMask, operands);
-            }
-            else
-            {
-                result = context.ImageSampleImplicitLod(resultType, image, pCoords, operandsMask, operands);
-            }
-
-            var swizzledResultType = AggregateType.FP32;
-
-            if (colorIsVector)
-            {
-                swizzledResultType = texOp.GetVectorType(swizzledResultType);
-
-                result = GetSwizzledResult(context, result, swizzledResultType, texOp.Index);
-            }
-
-            return new OperationResult(swizzledResultType, result);
-        }
-
-        private static OperationResult GenerateTextureSize(CodeGenContext context, AstOperation operation)
-        {
-            AstTextureOperation texOp = (AstTextureOperation)operation;
-
-            bool isBindless = (texOp.Flags & TextureFlags.Bindless) != 0;
-
-            // TODO: Bindless texture support. For now we just return 0.
-            if (isBindless)
-            {
-                return new OperationResult(AggregateType.S32, context.Constant(context.TypeS32(), 0));
-            }
-
-            bool isIndexed = (texOp.Type & SamplerType.Indexed) != 0;
-
-            SpvInstruction index = null;
-
-            if (isIndexed)
-            {
-                index = context.GetS32(texOp.GetSource(0));
-            }
-
-            var meta = new TextureMeta(texOp.CbufSlot, texOp.Handle, texOp.Format);
-
-            (var imageType, var sampledImageType, var sampledImageVariable) = context.Samplers[meta];
-
-            var image = context.Load(sampledImageType, sampledImageVariable);
-            image = context.Image(imageType, image);
-
-            if (texOp.Index == 3)
-            {
-                return new OperationResult(AggregateType.S32, context.ImageQueryLevels(context.TypeS32(), image));
-            }
-            else
-            {
-                var type = context.SamplersTypes[meta];
-                bool hasLod = !type.HasFlag(SamplerType.Multisample) && type != SamplerType.TextureBuffer;
-
-                int dimensions = (type & SamplerType.Mask) == SamplerType.TextureCube ? 2 : type.GetDimensions();
-
-                if (type.HasFlag(SamplerType.Array))
-                {
-                    dimensions++;
-                }
-
-                var resultType = dimensions == 1 ? context.TypeS32() : context.TypeVector(context.TypeS32(), dimensions);
-
-                SpvInstruction result;
-
-                if (hasLod)
-                {
-                    int lodSrcIndex = isBindless || isIndexed ? 1 : 0;
-                    var lod = context.GetS32(operation.GetSource(lodSrcIndex));
-                    result = context.ImageQuerySizeLod(resultType, image, lod);
-                }
-                else
-                {
-                    result = context.ImageQuerySize(resultType, image);
-                }
-
-                if (dimensions != 1)
-                {
-                    result = context.CompositeExtract(context.TypeS32(), result, (SpvLiteralInteger)texOp.Index);
-                }
-
-                if (texOp.Index < 2 || (type & SamplerType.Mask) == SamplerType.Texture3D)
-                {
-                    result = ScalingHelpers.ApplyUnscaling(context, texOp.WithType(type), result, isBindless, isIndexed);
-                }
-
-                return new OperationResult(AggregateType.S32, result);
-            }
-        }
-
-        private static OperationResult GenerateTruncate(CodeGenContext context, AstOperation operation)
-        {
-            return GenerateUnary(context, operation, context.Delegates.GlslTrunc, null);
-        }
-
-        private static OperationResult GenerateUnpackDouble2x32(CodeGenContext context, AstOperation operation)
-        {
-            var value = context.GetFP64(operation.GetSource(0));
-            var vector = context.GlslUnpackDouble2x32(context.TypeVector(context.TypeU32(), 2), value);
-            var result = context.CompositeExtract(context.TypeU32(), vector, operation.Index);
-
-            return new OperationResult(AggregateType.U32, result);
-        }
-
-        private static OperationResult GenerateUnpackHalf2x16(CodeGenContext context, AstOperation operation)
-        {
-            var value = context.GetU32(operation.GetSource(0));
-            var vector = context.GlslUnpackHalf2x16(context.TypeVector(context.TypeFP32(), 2), value);
-            var result = context.CompositeExtract(context.TypeFP32(), vector, operation.Index);
-
-            return new OperationResult(AggregateType.FP32, result);
-        }
-
-        private static OperationResult GenerateVectorExtract(CodeGenContext context, AstOperation operation)
-        {
-            var vector = context.GetWithType(operation.GetSource(0), out AggregateType vectorType);
-            var scalarType = vectorType & ~AggregateType.ElementCountMask;
-            var resultType = context.GetType(scalarType);
-            SpvInstruction result;
-
-            if (operation.GetSource(1) is AstOperand indexOperand && indexOperand.Type == OperandType.Constant)
-            {
-                result = context.CompositeExtract(resultType, vector, (SpvLiteralInteger)indexOperand.Value);
-            }
-            else
-            {
-                var index = context.Get(AggregateType.S32, operation.GetSource(1));
-                result = context.VectorExtractDynamic(resultType, vector, index);
-            }
-
-            return new OperationResult(scalarType, result);
-        }
-
-        private static OperationResult GenerateVoteAll(CodeGenContext context, AstOperation operation)
-        {
-            var execution = context.Constant(context.TypeU32(), Scope.Subgroup);
-            var result = context.GroupNonUniformAll(context.TypeBool(), execution, context.Get(AggregateType.Bool, operation.GetSource(0)));
-            return new OperationResult(AggregateType.Bool, result);
-        }
-
-        private static OperationResult GenerateVoteAllEqual(CodeGenContext context, AstOperation operation)
-        {
-            var execution = context.Constant(context.TypeU32(), Scope.Subgroup);
-            var result = context.GroupNonUniformAllEqual(context.TypeBool(), execution, context.Get(AggregateType.Bool, operation.GetSource(0)));
-            return new OperationResult(AggregateType.Bool, result);
-        }
-
-        private static OperationResult GenerateVoteAny(CodeGenContext context, AstOperation operation)
-        {
-            var execution = context.Constant(context.TypeU32(), Scope.Subgroup);
-            var result = context.GroupNonUniformAny(context.TypeBool(), execution, context.Get(AggregateType.Bool, operation.GetSource(0)));
-            return new OperationResult(AggregateType.Bool, result);
-        }
-
-        private static OperationResult GenerateCompare(
-            CodeGenContext context,
-            AstOperation operation,
-            Func<SpvInstruction, SpvInstruction, SpvInstruction, SpvInstruction> emitF,
-            Func<SpvInstruction, SpvInstruction, SpvInstruction, SpvInstruction> emitI)
-        {
-            var src1 = operation.GetSource(0);
-            var src2 = operation.GetSource(1);
-
-            SpvInstruction result;
-
-            if (operation.Inst.HasFlag(Instruction.FP64))
-            {
-                result = emitF(context.TypeBool(), context.GetFP64(src1), context.GetFP64(src2));
-            }
-            else if (operation.Inst.HasFlag(Instruction.FP32))
-            {
-                result = emitF(context.TypeBool(), context.GetFP32(src1), context.GetFP32(src2));
-            }
-            else
-            {
-                result = emitI(context.TypeBool(), context.GetS32(src1), context.GetS32(src2));
-            }
-
-            return new OperationResult(AggregateType.Bool, result);
-        }
-
-        private static OperationResult GenerateCompareU32(
-            CodeGenContext context,
-            AstOperation operation,
-            Func<SpvInstruction, SpvInstruction, SpvInstruction, SpvInstruction> emitU)
-        {
-            var src1 = operation.GetSource(0);
-            var src2 = operation.GetSource(1);
-
-            var result = emitU(context.TypeBool(), context.GetU32(src1), context.GetU32(src2));
-
-            return new OperationResult(AggregateType.Bool, result);
-        }
-
-        private static OperationResult GenerateAtomicMemoryBinary(
-            CodeGenContext context,
-            AstOperation operation,
-            Func<SpvInstruction, SpvInstruction, SpvInstruction, SpvInstruction, SpvInstruction, SpvInstruction> emitU)
-        {
-            var value = context.GetU32(operation.GetSource(2));
-
-            SpvInstruction elemPointer;
-
-            if (operation.StorageKind == StorageKind.StorageBuffer)
-            {
-                elemPointer = GetStorageElemPointer(context, operation);
-            }
-            else if (operation.StorageKind == StorageKind.SharedMemory)
-            {
-                var offset = context.GetU32(operation.GetSource(0));
-                elemPointer = context.AccessChain(context.TypePointer(StorageClass.Workgroup, context.TypeU32()), context.SharedMemory, offset);
-            }
-            else
-            {
-                throw new InvalidOperationException($"Invalid storage kind \"{operation.StorageKind}\".");
-            }
-
-            var one = context.Constant(context.TypeU32(), 1);
-            var zero = context.Constant(context.TypeU32(), 0);
-
-            return new OperationResult(AggregateType.U32, emitU(context.TypeU32(), elemPointer, one, zero, value));
-        }
-
-        private static OperationResult GenerateAtomicMemoryCas(CodeGenContext context, AstOperation operation)
-        {
-            var value0 = context.GetU32(operation.GetSource(2));
-            var value1 = context.GetU32(operation.GetSource(3));
-
-            SpvInstruction elemPointer;
-
-            if (operation.StorageKind == StorageKind.StorageBuffer)
-            {
-                elemPointer = GetStorageElemPointer(context, operation);
-            }
-            else if (operation.StorageKind == StorageKind.SharedMemory)
-            {
-                var offset = context.GetU32(operation.GetSource(0));
-                elemPointer = context.AccessChain(context.TypePointer(StorageClass.Workgroup, context.TypeU32()), context.SharedMemory, offset);
-            }
-            else
-            {
-                throw new InvalidOperationException($"Invalid storage kind \"{operation.StorageKind}\".");
-            }
-
-            var one = context.Constant(context.TypeU32(), 1);
-            var zero = context.Constant(context.TypeU32(), 0);
-
-            return new OperationResult(AggregateType.U32, context.AtomicCompareExchange(context.TypeU32(), elemPointer, one, zero, zero, value1, value0));
-        }
-
-        private static OperationResult GenerateLoadOrStore(CodeGenContext context, AstOperation operation, bool isStore)
-        {
-            StorageKind storageKind = operation.StorageKind;
-
-            SpvInstruction pointer;
-            AggregateType varType;
-            int srcIndex = 0;
-
-            switch (storageKind)
-            {
-                case StorageKind.Input:
-                case StorageKind.InputPerPatch:
-                case StorageKind.Output:
-                case StorageKind.OutputPerPatch:
-                    if (!(operation.GetSource(srcIndex++) is AstOperand varId) || varId.Type != OperandType.Constant)
-                    {
-                        throw new InvalidOperationException($"First input of {operation.Inst} with {storageKind} storage must be a constant operand.");
-                    }
-
-                    IoVariable ioVariable = (IoVariable)varId.Value;
-                    bool isOutput = storageKind.IsOutput();
-                    bool isPerPatch = storageKind.IsPerPatch();
-                    int location = 0;
-                    int component = 0;
-
-                    if (context.Config.HasPerLocationInputOrOutput(ioVariable, isOutput))
-                    {
-                        if (!(operation.GetSource(srcIndex++) is AstOperand vecIndex) || vecIndex.Type != OperandType.Constant)
-                        {
-                            throw new InvalidOperationException($"Second input of {operation.Inst} with {storageKind} storage must be a constant operand.");
-                        }
-
-                        location = vecIndex.Value;
-
-                        if (operation.SourcesCount > srcIndex &&
-                            operation.GetSource(srcIndex) is AstOperand elemIndex &&
-                            elemIndex.Type == OperandType.Constant &&
-                            context.Config.HasPerLocationInputOrOutputComponent(ioVariable, location, elemIndex.Value, isOutput))
-                        {
-                            component = elemIndex.Value;
-                            srcIndex++;
-                        }
-                    }
-
-                    if (ioVariable == IoVariable.UserDefined)
-                    {
-                        varType = context.Config.GetUserDefinedType(location, isOutput);
-                    }
-                    else if (ioVariable == IoVariable.FragmentOutputColor)
-                    {
-                        varType = context.Config.GetFragmentOutputColorType(location);
-                    }
-                    else if (ioVariable == IoVariable.FragmentOutputIsBgra)
-                    {
-                        var pointerType = context.TypePointer(StorageClass.Uniform, context.TypeU32());
-                        var elemIndex = context.Get(AggregateType.S32, operation.GetSource(srcIndex++));
-                        pointer = context.AccessChain(pointerType, context.SupportBuffer, context.Constant(context.TypeU32(), 1), elemIndex);
-                        varType = AggregateType.U32;
-
-                        break;
-                    }
-                    else if (ioVariable == IoVariable.SupportBlockRenderScale)
-                    {
-                        var pointerType = context.TypePointer(StorageClass.Uniform, context.TypeFP32());
-                        var elemIndex = context.Get(AggregateType.S32, operation.GetSource(srcIndex++));
-                        pointer = context.AccessChain(pointerType, context.SupportBuffer, context.Constant(context.TypeU32(), 4), elemIndex);
-                        varType = AggregateType.FP32;
-
-                        break;
-                    }
-                    else if (ioVariable == IoVariable.SupportBlockViewInverse)
-                    {
-                        var pointerType = context.TypePointer(StorageClass.Uniform, context.TypeFP32());
-                        var elemIndex = context.Get(AggregateType.S32, operation.GetSource(srcIndex++));
-                        pointer = context.AccessChain(pointerType, context.SupportBuffer, context.Constant(context.TypeU32(), 2), elemIndex);
-                        varType = AggregateType.FP32;
-
-                        break;
-                    }
-                    else
-                    {
-                        (_, varType) = IoMap.GetSpirvBuiltIn(ioVariable);
-                    }
-
-                    varType &= AggregateType.ElementTypeMask;
-
-                    int inputsCount = (isStore ? operation.SourcesCount - 1 : operation.SourcesCount) - srcIndex;
-                    var storageClass = isOutput ? StorageClass.Output : StorageClass.Input;
-
-                    var ioDefinition = new IoDefinition(storageKind, ioVariable, location, component);
-                    var dict = isPerPatch
-                        ? (isOutput ? context.OutputsPerPatch : context.InputsPerPatch)
-                        : (isOutput ? context.Outputs : context.Inputs);
-
-                    SpvInstruction baseObj = dict[ioDefinition];
-                    SpvInstruction e0, e1, e2;
-
-                    switch (inputsCount)
-                    {
-                        case 0:
-                            pointer = baseObj;
-                            break;
-                        case 1:
-                            e0 = context.Get(AggregateType.S32, operation.GetSource(srcIndex++));
-                            pointer = context.AccessChain(context.TypePointer(storageClass, context.GetType(varType)), baseObj, e0);
-                            break;
-                        case 2:
-                            e0 = context.Get(AggregateType.S32, operation.GetSource(srcIndex++));
-                            e1 = context.Get(AggregateType.S32, operation.GetSource(srcIndex++));
-                            pointer = context.AccessChain(context.TypePointer(storageClass, context.GetType(varType)), baseObj, e0, e1);
-                            break;
-                        case 3:
-                            e0 = context.Get(AggregateType.S32, operation.GetSource(srcIndex++));
-                            e1 = context.Get(AggregateType.S32, operation.GetSource(srcIndex++));
-                            e2 = context.Get(AggregateType.S32, operation.GetSource(srcIndex++));
-                            pointer = context.AccessChain(context.TypePointer(storageClass, context.GetType(varType)), baseObj, e0, e1, e2);
-                            break;
-                        default:
-                            var indexes = new SpvInstruction[inputsCount];
-                            int index = 0;
-
-                            for (; index < inputsCount; srcIndex++, index++)
-                            {
-                                indexes[index] = context.Get(AggregateType.S32, operation.GetSource(srcIndex));
-                            }
-
-                            pointer = context.AccessChain(context.TypePointer(storageClass, context.GetType(varType)), baseObj, indexes);
-                            break;
-                    }
-                    break;
-
-                default:
-                    throw new InvalidOperationException($"Invalid storage kind {storageKind}.");
-            }
-
-            if (isStore)
-            {
-                context.Store(pointer, context.Get(varType, operation.GetSource(srcIndex)));
-                return OperationResult.Invalid;
-            }
-            else
-            {
-                var result = context.Load(context.GetType(varType), pointer);
-                return new OperationResult(varType, result);
-            }
-        }
-
-        private static SpvInstruction GetScalarInput(CodeGenContext context, IoVariable ioVariable)
-        {
-            (_, var varType) = IoMap.GetSpirvBuiltIn(ioVariable);
-            varType &= AggregateType.ElementTypeMask;
-
-            var ioDefinition = new IoDefinition(StorageKind.Input, ioVariable);
-
-            return context.Load(context.GetType(varType), context.Inputs[ioDefinition]);
-        }
-
-        private static void GenerateStoreSharedSmallInt(CodeGenContext context, AstOperation operation, int bitSize)
-        {
-            var offset = context.Get(AggregateType.U32, operation.GetSource(0));
-            var value = context.Get(AggregateType.U32, operation.GetSource(1));
-
-            var wordOffset = context.ShiftRightLogical(context.TypeU32(), offset, context.Constant(context.TypeU32(), 2));
-            var bitOffset = context.BitwiseAnd(context.TypeU32(), offset, context.Constant(context.TypeU32(), 3));
-            bitOffset = context.ShiftLeftLogical(context.TypeU32(), bitOffset, context.Constant(context.TypeU32(), 3));
-
-            var memory = context.SharedMemory;
-
-            var elemPointer = context.AccessChain(context.TypePointer(StorageClass.Workgroup, context.TypeU32()), memory, wordOffset);
-
-            GenerateStoreSmallInt(context, elemPointer, bitOffset, value, bitSize);
-        }
-
-        private static void GenerateStoreStorageSmallInt(CodeGenContext context, AstOperation operation, int bitSize)
-        {
-            var i0 = context.Get(AggregateType.S32, operation.GetSource(0));
-            var offset = context.Get(AggregateType.U32, operation.GetSource(1));
-            var value = context.Get(AggregateType.U32, operation.GetSource(2));
-
-            var wordOffset = context.ShiftRightLogical(context.TypeU32(), offset, context.Constant(context.TypeU32(), 2));
-            var bitOffset = context.BitwiseAnd(context.TypeU32(), offset, context.Constant(context.TypeU32(), 3));
-            bitOffset = context.ShiftLeftLogical(context.TypeU32(), bitOffset, context.Constant(context.TypeU32(), 3));
-
-            var sbVariable = context.StorageBuffersArray;
-
-            var i1 = context.Constant(context.TypeS32(), 0);
-
-            var elemPointer = context.AccessChain(context.TypePointer(StorageClass.Uniform, context.TypeU32()), sbVariable, i0, i1, wordOffset);
-
-            GenerateStoreSmallInt(context, elemPointer, bitOffset, value, bitSize);
-        }
-
-        private static void GenerateStoreSmallInt(
-            CodeGenContext context,
-            SpvInstruction elemPointer,
-            SpvInstruction bitOffset,
-            SpvInstruction value,
-            int bitSize)
-        {
-            var loopStart = context.Label();
-            var loopEnd = context.Label();
-
-            context.Branch(loopStart);
-            context.AddLabel(loopStart);
-
-            var oldValue = context.Load(context.TypeU32(), elemPointer);
-            var newValue = context.BitFieldInsert(context.TypeU32(), oldValue, value, bitOffset, context.Constant(context.TypeU32(), bitSize));
-
-            var one = context.Constant(context.TypeU32(), 1);
-            var zero = context.Constant(context.TypeU32(), 0);
-
-            var result = context.AtomicCompareExchange(context.TypeU32(), elemPointer, one, zero, zero, newValue, oldValue);
-            var failed = context.INotEqual(context.TypeBool(), result, oldValue);
-
-            context.LoopMerge(loopEnd, loopStart, LoopControlMask.MaskNone);
-            context.BranchConditional(failed, loopStart, loopEnd);
-
-            context.AddLabel(loopEnd);
-        }
-
-        private static OperationResult GetZeroOperationResult(
-            CodeGenContext context,
-            AstTextureOperation texOp,
-            AggregateType scalarType,
-            bool isVector)
-        {
-            var zero = scalarType switch
-            {
-                AggregateType.S32 => context.Constant(context.TypeS32(), 0),
-                AggregateType.U32 => context.Constant(context.TypeU32(), 0u),
-                _ => context.Constant(context.TypeFP32(), 0f),
-            };
-
-            if (isVector)
-            {
-                AggregateType outputType = texOp.GetVectorType(scalarType);
-
-                if ((outputType & AggregateType.ElementCountMask) != 0)
-                {
-                    int componentsCount = BitOperations.PopCount((uint)texOp.Index);
-
-                    SpvInstruction[] values = new SpvInstruction[componentsCount];
-
-                    values.AsSpan().Fill(zero);
-
-                    return new OperationResult(outputType, context.ConstantComposite(context.GetType(outputType), values));
-                }
-            }
-
-            return new OperationResult(scalarType, zero);
-        }
-
-        private static SpvInstruction GetSwizzledResult(CodeGenContext context, SpvInstruction vector, AggregateType swizzledResultType, int mask)
-        {
-            if ((swizzledResultType & AggregateType.ElementCountMask) != 0)
-            {
-                SpvLiteralInteger[] components = new SpvLiteralInteger[BitOperations.PopCount((uint)mask)];
-
-                int componentIndex = 0;
-
-                for (int i = 0; i < 4; i++)
-                {
-                    if ((mask & (1 << i)) != 0)
-                    {
-                        components[componentIndex++] = i;
-                    }
-                }
-
-                return context.VectorShuffle(context.GetType(swizzledResultType), vector, vector, components);
-            }
-            else
-            {
-                int componentIndex = (int)BitOperations.TrailingZeroCount(mask);
-
-                return context.CompositeExtract(context.GetType(swizzledResultType), vector, (SpvLiteralInteger)componentIndex);
-            }
-        }
-
-        private static SpvInstruction GetStorageElemPointer(CodeGenContext context, AstOperation operation)
-        {
-            var sbVariable = context.StorageBuffersArray;
-            var i0 = context.Get(AggregateType.S32, operation.GetSource(0));
-            var i1 = context.Constant(context.TypeS32(), 0);
-            var i2 = context.Get(AggregateType.S32, operation.GetSource(1));
-
-            return context.AccessChain(context.TypePointer(StorageClass.Uniform, context.TypeU32()), sbVariable, i0, i1, i2);
-        }
-
-        private static OperationResult GenerateUnary(
-            CodeGenContext context,
-            AstOperation operation,
-            Func<SpvInstruction, SpvInstruction, SpvInstruction> emitF,
-            Func<SpvInstruction, SpvInstruction, SpvInstruction> emitI)
-        {
-            var source = operation.GetSource(0);
-
-            if (operation.Inst.HasFlag(Instruction.FP64))
-            {
-                return new OperationResult(AggregateType.FP64, emitF(context.TypeFP64(), context.GetFP64(source)));
-            }
-            else if (operation.Inst.HasFlag(Instruction.FP32))
-            {
-                return new OperationResult(AggregateType.FP32, emitF(context.TypeFP32(), context.GetFP32(source)));
-            }
-            else
-            {
-                return new OperationResult(AggregateType.S32, emitI(context.TypeS32(), context.GetS32(source)));
-            }
-        }
-
-        private static OperationResult GenerateUnaryBool(
-            CodeGenContext context,
-            AstOperation operation,
-            Func<SpvInstruction, SpvInstruction, SpvInstruction> emitB)
-        {
-            var source = operation.GetSource(0);
-            return new OperationResult(AggregateType.Bool, emitB(context.TypeBool(), context.Get(AggregateType.Bool, source)));
-        }
-
-         private static OperationResult GenerateUnaryFP32(
-            CodeGenContext context,
-            AstOperation operation,
-            Func<SpvInstruction, SpvInstruction, SpvInstruction> emit)
-        {
-            var source = operation.GetSource(0);
-            return new OperationResult(AggregateType.FP32, emit(context.TypeFP32(), context.GetFP32(source)));
-        }
-
-        private static OperationResult GenerateUnaryS32(
-            CodeGenContext context,
-            AstOperation operation,
-            Func<SpvInstruction, SpvInstruction, SpvInstruction> emitS)
-        {
-            var source = operation.GetSource(0);
-            return new OperationResult(AggregateType.S32, emitS(context.TypeS32(), context.GetS32(source)));
-        }
-
-        private static OperationResult GenerateBinary(
-            CodeGenContext context,
-            AstOperation operation,
-            Func<SpvInstruction, SpvInstruction, SpvInstruction, SpvInstruction> emitF,
-            Func<SpvInstruction, SpvInstruction, SpvInstruction, SpvInstruction> emitI)
-        {
-            var src1 = operation.GetSource(0);
-            var src2 = operation.GetSource(1);
-
-            if (operation.Inst.HasFlag(Instruction.FP64))
-            {
-                var result = emitF(context.TypeFP64(), context.GetFP64(src1), context.GetFP64(src2));
-
-                if (!context.Config.GpuAccessor.QueryHostReducedPrecision())
-                {
-                    context.Decorate(result, Decoration.NoContraction);
-                }
-
-                return new OperationResult(AggregateType.FP64, result);
-            }
-            else if (operation.Inst.HasFlag(Instruction.FP32))
-            {
-                var result = emitF(context.TypeFP32(), context.GetFP32(src1), context.GetFP32(src2));
-
-                if (!context.Config.GpuAccessor.QueryHostReducedPrecision())
-                {
-                    context.Decorate(result, Decoration.NoContraction);
-                }
-
-                return new OperationResult(AggregateType.FP32, result);
-            }
-            else
-            {
-                return new OperationResult(AggregateType.S32, emitI(context.TypeS32(), context.GetS32(src1), context.GetS32(src2)));
-            }
-        }
-
-        private static OperationResult GenerateBinaryBool(
-            CodeGenContext context,
-            AstOperation operation,
-            Func<SpvInstruction, SpvInstruction, SpvInstruction, SpvInstruction> emitB)
-        {
-            var src1 = operation.GetSource(0);
-            var src2 = operation.GetSource(1);
-
-            return new OperationResult(AggregateType.Bool, emitB(context.TypeBool(), context.Get(AggregateType.Bool, src1), context.Get(AggregateType.Bool, src2)));
-        }
-
-        private static OperationResult GenerateBinaryS32(
-            CodeGenContext context,
-            AstOperation operation,
-            Func<SpvInstruction, SpvInstruction, SpvInstruction, SpvInstruction> emitS)
-        {
-            var src1 = operation.GetSource(0);
-            var src2 = operation.GetSource(1);
-
-            return new OperationResult(AggregateType.S32, emitS(context.TypeS32(), context.GetS32(src1), context.GetS32(src2)));
-        }
-
-        private static OperationResult GenerateBinaryU32(
-            CodeGenContext context,
-            AstOperation operation,
-            Func<SpvInstruction, SpvInstruction, SpvInstruction, SpvInstruction> emitU)
-        {
-            var src1 = operation.GetSource(0);
-            var src2 = operation.GetSource(1);
-
-            return new OperationResult(AggregateType.U32, emitU(context.TypeU32(), context.GetU32(src1), context.GetU32(src2)));
-        }
-
-        private static OperationResult GenerateTernary(
-            CodeGenContext context,
-            AstOperation operation,
-            Func<SpvInstruction, SpvInstruction, SpvInstruction, SpvInstruction, SpvInstruction> emitF,
-            Func<SpvInstruction, SpvInstruction, SpvInstruction, SpvInstruction, SpvInstruction> emitI)
-        {
-            var src1 = operation.GetSource(0);
-            var src2 = operation.GetSource(1);
-            var src3 = operation.GetSource(2);
-
-            if (operation.Inst.HasFlag(Instruction.FP64))
-            {
-                var result = emitF(context.TypeFP64(), context.GetFP64(src1), context.GetFP64(src2), context.GetFP64(src3));
-
-                if (!context.Config.GpuAccessor.QueryHostReducedPrecision())
-                {
-                    context.Decorate(result, Decoration.NoContraction);
-                }
-
-                return new OperationResult(AggregateType.FP64, result);
-            }
-            else if (operation.Inst.HasFlag(Instruction.FP32))
-            {
-                var result = emitF(context.TypeFP32(), context.GetFP32(src1), context.GetFP32(src2), context.GetFP32(src3));
-
-                if (!context.Config.GpuAccessor.QueryHostReducedPrecision())
-                {
-                    context.Decorate(result, Decoration.NoContraction);
-                }
-
-                return new OperationResult(AggregateType.FP32, result);
-            }
-            else
-            {
-                return new OperationResult(AggregateType.S32, emitI(context.TypeS32(), context.GetS32(src1), context.GetS32(src2), context.GetS32(src3)));
-            }
-        }
-
-        private static OperationResult GenerateTernaryU32(
-            CodeGenContext context,
-            AstOperation operation,
-            Func<SpvInstruction, SpvInstruction, SpvInstruction, SpvInstruction, SpvInstruction> emitU)
-        {
-            var src1 = operation.GetSource(0);
-            var src2 = operation.GetSource(1);
-            var src3 = operation.GetSource(2);
-
-            return new OperationResult(AggregateType.U32, emitU(
-                context.TypeU32(),
-                context.GetU32(src1),
-                context.GetU32(src2),
-                context.GetU32(src3)));
-        }
-
-        private static OperationResult GenerateBitfieldExtractS32(
-            CodeGenContext context,
-            AstOperation operation,
-            Func<SpvInstruction, SpvInstruction, SpvInstruction, SpvInstruction, SpvInstruction> emitS)
-        {
-            var src1 = operation.GetSource(0);
-            var src2 = operation.GetSource(1);
-            var src3 = operation.GetSource(2);
-
-            return new OperationResult(AggregateType.S32, emitS(
-                context.TypeS32(),
-                context.GetS32(src1),
-                context.GetU32(src2),
-                context.GetU32(src3)));
-        }
-
-        private static OperationResult GenerateBitfieldInsert(
-            CodeGenContext context,
-            AstOperation operation,
-            Func<SpvInstruction, SpvInstruction, SpvInstruction, SpvInstruction, SpvInstruction, SpvInstruction> emitS)
-        {
-            var src1 = operation.GetSource(0);
-            var src2 = operation.GetSource(1);
-            var src3 = operation.GetSource(2);
-            var src4 = operation.GetSource(3);
-
-            return new OperationResult(AggregateType.U32, emitS(
-                context.TypeU32(),
-                context.GetU32(src1),
-                context.GetU32(src2),
-                context.GetU32(src3),
-                context.GetU32(src4)));
-        }
-    }
-}
diff --git a/Ryujinx.Graphics.Shader/CodeGen/Spirv/IoMap.cs b/Ryujinx.Graphics.Shader/CodeGen/Spirv/IoMap.cs
deleted file mode 100644
index d2ff0085..00000000
--- a/Ryujinx.Graphics.Shader/CodeGen/Spirv/IoMap.cs
+++ /dev/null
@@ -1,86 +0,0 @@
-using Ryujinx.Graphics.Shader.IntermediateRepresentation;
-using Ryujinx.Graphics.Shader.Translation;
-using static Spv.Specification;
-
-namespace Ryujinx.Graphics.Shader.CodeGen.Spirv
-{
-    static class IoMap
-    {
-        // At least 16 attributes are guaranteed by the spec.
-        private const int MaxAttributes = 16;
-
-        public static (BuiltIn, AggregateType) GetSpirvBuiltIn(IoVariable ioVariable)
-        {
-            return ioVariable switch
-            {
-                IoVariable.BaseInstance => (BuiltIn.BaseInstance, AggregateType.S32),
-                IoVariable.BaseVertex => (BuiltIn.BaseVertex, AggregateType.S32),
-                IoVariable.ClipDistance => (BuiltIn.ClipDistance, AggregateType.Array | AggregateType.FP32),
-                IoVariable.CtaId => (BuiltIn.WorkgroupId, AggregateType.Vector3 | AggregateType.U32),
-                IoVariable.DrawIndex => (BuiltIn.DrawIndex, AggregateType.S32),
-                IoVariable.FragmentCoord => (BuiltIn.FragCoord, AggregateType.Vector4 | AggregateType.FP32),
-                IoVariable.FragmentOutputDepth => (BuiltIn.FragDepth, AggregateType.FP32),
-                IoVariable.FrontFacing => (BuiltIn.FrontFacing, AggregateType.Bool),
-                IoVariable.InstanceId => (BuiltIn.InstanceId, AggregateType.S32),
-                IoVariable.InstanceIndex => (BuiltIn.InstanceIndex, AggregateType.S32),
-                IoVariable.InvocationId => (BuiltIn.InvocationId, AggregateType.S32),
-                IoVariable.Layer => (BuiltIn.Layer, AggregateType.S32),
-                IoVariable.PatchVertices => (BuiltIn.PatchVertices, AggregateType.S32),
-                IoVariable.PointCoord => (BuiltIn.PointCoord, AggregateType.Vector2 | AggregateType.FP32),
-                IoVariable.PointSize => (BuiltIn.PointSize, AggregateType.FP32),
-                IoVariable.Position => (BuiltIn.Position, AggregateType.Vector4 | AggregateType.FP32),
-                IoVariable.PrimitiveId => (BuiltIn.PrimitiveId, AggregateType.S32),
-                IoVariable.SubgroupEqMask => (BuiltIn.SubgroupEqMask, AggregateType.Vector4 | AggregateType.U32),
-                IoVariable.SubgroupGeMask => (BuiltIn.SubgroupGeMask, AggregateType.Vector4 | AggregateType.U32),
-                IoVariable.SubgroupGtMask => (BuiltIn.SubgroupGtMask, AggregateType.Vector4 | AggregateType.U32),
-                IoVariable.SubgroupLaneId => (BuiltIn.SubgroupLocalInvocationId, AggregateType.U32),
-                IoVariable.SubgroupLeMask => (BuiltIn.SubgroupLeMask, AggregateType.Vector4 | AggregateType.U32),
-                IoVariable.SubgroupLtMask => (BuiltIn.SubgroupLtMask, AggregateType.Vector4 | AggregateType.U32),
-                IoVariable.TessellationCoord => (BuiltIn.TessCoord, AggregateType.Vector3 | AggregateType.FP32),
-                IoVariable.TessellationLevelInner => (BuiltIn.TessLevelInner, AggregateType.Array | AggregateType.FP32),
-                IoVariable.TessellationLevelOuter => (BuiltIn.TessLevelOuter, AggregateType.Array | AggregateType.FP32),
-                IoVariable.ThreadId => (BuiltIn.LocalInvocationId, AggregateType.Vector3 | AggregateType.U32),
-                IoVariable.ThreadKill => (BuiltIn.HelperInvocation, AggregateType.Bool),
-                IoVariable.VertexId => (BuiltIn.VertexId, AggregateType.S32),
-                IoVariable.VertexIndex => (BuiltIn.VertexIndex, AggregateType.S32),
-                IoVariable.ViewportIndex => (BuiltIn.ViewportIndex, AggregateType.S32),
-                IoVariable.ViewportMask => (BuiltIn.ViewportMaskNV, AggregateType.Array | AggregateType.S32),
-                _ => (default, AggregateType.Invalid)
-            };
-        }
-
-        public static int GetSpirvBuiltInArrayLength(IoVariable ioVariable)
-        {
-            return ioVariable switch
-            {
-                IoVariable.ClipDistance => 8,
-                IoVariable.TessellationLevelInner => 2,
-                IoVariable.TessellationLevelOuter => 4,
-                IoVariable.ViewportMask => 1,
-                IoVariable.UserDefined => MaxAttributes,
-                _ => 1
-            };
-        }
-
-        public static bool IsPerVertex(IoVariable ioVariable, ShaderStage stage, bool isOutput)
-        {
-            switch (ioVariable)
-            {
-                case IoVariable.Layer:
-                case IoVariable.ViewportIndex:
-                case IoVariable.PointSize:
-                case IoVariable.Position:
-                case IoVariable.UserDefined:
-                case IoVariable.ClipDistance:
-                case IoVariable.PointCoord:
-                case IoVariable.ViewportMask:
-                return !isOutput &&
-                       (stage == ShaderStage.TessellationControl ||
-                       stage == ShaderStage.TessellationEvaluation ||
-                       stage == ShaderStage.Geometry);
-            }
-
-            return false;
-        }
-    }
-}
\ No newline at end of file
diff --git a/Ryujinx.Graphics.Shader/CodeGen/Spirv/OperationResult.cs b/Ryujinx.Graphics.Shader/CodeGen/Spirv/OperationResult.cs
deleted file mode 100644
index f80c8110..00000000
--- a/Ryujinx.Graphics.Shader/CodeGen/Spirv/OperationResult.cs
+++ /dev/null
@@ -1,19 +0,0 @@
-using Ryujinx.Graphics.Shader.Translation;
-using Spv.Generator;
-
-namespace Ryujinx.Graphics.Shader.CodeGen.Spirv
-{
-    readonly struct OperationResult
-    {
-        public static OperationResult Invalid => new OperationResult(AggregateType.Invalid, null);
-
-        public AggregateType Type { get; }
-        public Instruction Value { get; }
-
-        public OperationResult(AggregateType type, Instruction value)
-        {
-            Type = type;
-            Value = value;
-        }
-    }
-}
diff --git a/Ryujinx.Graphics.Shader/CodeGen/Spirv/ScalingHelpers.cs b/Ryujinx.Graphics.Shader/CodeGen/Spirv/ScalingHelpers.cs
deleted file mode 100644
index f6c218c6..00000000
--- a/Ryujinx.Graphics.Shader/CodeGen/Spirv/ScalingHelpers.cs
+++ /dev/null
@@ -1,227 +0,0 @@
-using Ryujinx.Graphics.Shader.IntermediateRepresentation;
-using Ryujinx.Graphics.Shader.StructuredIr;
-using Ryujinx.Graphics.Shader.Translation;
-using static Spv.Specification;
-
-namespace Ryujinx.Graphics.Shader.CodeGen.Spirv
-{
-    using SpvInstruction = Spv.Generator.Instruction;
-
-    static class ScalingHelpers
-    {
-        public static SpvInstruction ApplyScaling(
-            CodeGenContext context,
-            AstTextureOperation texOp,
-            SpvInstruction vector,
-            bool intCoords,
-            bool isBindless,
-            bool isIndexed,
-            bool isArray,
-            int pCount)
-        {
-            if (intCoords)
-            {
-                if (context.Config.Stage.SupportsRenderScale() &&
-                    !isBindless &&
-                    !isIndexed)
-                {
-                    int index = texOp.Inst == Instruction.ImageLoad
-                        ? context.Config.GetTextureDescriptors().Length + context.Config.FindImageDescriptorIndex(texOp)
-                        : context.Config.FindTextureDescriptorIndex(texOp);
-
-                    if (pCount == 3 && isArray)
-                    {
-                        return ApplyScaling2DArray(context, vector, index);
-                    }
-                    else if (pCount == 2 && !isArray)
-                    {
-                        return ApplyScaling2D(context, vector, index);
-                    }
-                }
-            }
-
-            return vector;
-        }
-
-        private static SpvInstruction ApplyScaling2DArray(CodeGenContext context, SpvInstruction vector, int index)
-        {
-            // The array index is not scaled, just x and y.
-            var vectorXY = context.VectorShuffle(context.TypeVector(context.TypeS32(), 2), vector, vector, 0, 1);
-            var vectorZ = context.CompositeExtract(context.TypeS32(), vector, 2);
-            var vectorXYScaled = ApplyScaling2D(context, vectorXY, index);
-            var vectorScaled = context.CompositeConstruct(context.TypeVector(context.TypeS32(), 3), vectorXYScaled, vectorZ);
-
-            return vectorScaled;
-        }
-
-        private static SpvInstruction ApplyScaling2D(CodeGenContext context, SpvInstruction vector, int index)
-        {
-            var pointerType = context.TypePointer(StorageClass.Uniform, context.TypeFP32());
-            var fieldIndex = context.Constant(context.TypeU32(), 4);
-            var scaleIndex = context.Constant(context.TypeU32(), index);
-
-            if (context.Config.Stage == ShaderStage.Vertex)
-            {
-                var scaleCountPointerType = context.TypePointer(StorageClass.Uniform, context.TypeS32());
-                var scaleCountElemPointer = context.AccessChain(scaleCountPointerType, context.SupportBuffer, context.Constant(context.TypeU32(), 3));
-                var scaleCount = context.Load(context.TypeS32(), scaleCountElemPointer);
-
-                scaleIndex = context.IAdd(context.TypeU32(), scaleIndex, scaleCount);
-            }
-
-            scaleIndex = context.IAdd(context.TypeU32(), scaleIndex, context.Constant(context.TypeU32(), 1));
-
-            var scaleElemPointer = context.AccessChain(pointerType, context.SupportBuffer, fieldIndex, scaleIndex);
-            var scale = context.Load(context.TypeFP32(), scaleElemPointer);
-
-            var ivector2Type = context.TypeVector(context.TypeS32(), 2);
-            var localVector = context.CoordTemp;
-
-            var passthrough = context.FOrdEqual(context.TypeBool(), scale, context.Constant(context.TypeFP32(), 1f));
-
-            var mergeLabel = context.Label();
-
-            if (context.Config.Stage == ShaderStage.Fragment)
-            {
-                var scaledInterpolatedLabel = context.Label();
-                var scaledNoInterpolationLabel = context.Label();
-
-                var needsInterpolation = context.FOrdLessThan(context.TypeBool(), scale, context.Constant(context.TypeFP32(), 0f));
-
-                context.SelectionMerge(mergeLabel, SelectionControlMask.MaskNone);
-                context.BranchConditional(needsInterpolation, scaledInterpolatedLabel, scaledNoInterpolationLabel);
-
-                // scale < 0.0
-                context.AddLabel(scaledInterpolatedLabel);
-
-                ApplyScalingInterpolated(context, localVector, vector, scale);
-                context.Branch(mergeLabel);
-
-                // scale >= 0.0
-                context.AddLabel(scaledNoInterpolationLabel);
-
-                ApplyScalingNoInterpolation(context, localVector, vector, scale);
-                context.Branch(mergeLabel);
-
-                context.AddLabel(mergeLabel);
-
-                var passthroughLabel = context.Label();
-                var finalMergeLabel = context.Label();
-
-                context.SelectionMerge(finalMergeLabel, SelectionControlMask.MaskNone);
-                context.BranchConditional(passthrough, passthroughLabel, finalMergeLabel);
-
-                context.AddLabel(passthroughLabel);
-
-                context.Store(localVector, vector);
-                context.Branch(finalMergeLabel);
-
-                context.AddLabel(finalMergeLabel);
-
-                return context.Load(ivector2Type, localVector);
-            }
-            else
-            {
-                var passthroughLabel = context.Label();
-                var scaledLabel = context.Label();
-
-                context.SelectionMerge(mergeLabel, SelectionControlMask.MaskNone);
-                context.BranchConditional(passthrough, passthroughLabel, scaledLabel);
-
-                // scale == 1.0
-                context.AddLabel(passthroughLabel);
-
-                context.Store(localVector, vector);
-                context.Branch(mergeLabel);
-
-                // scale != 1.0
-                context.AddLabel(scaledLabel);
-
-                ApplyScalingNoInterpolation(context, localVector, vector, scale);
-                context.Branch(mergeLabel);
-
-                context.AddLabel(mergeLabel);
-
-                return context.Load(ivector2Type, localVector);
-            }
-        }
-
-        private static void ApplyScalingInterpolated(CodeGenContext context, SpvInstruction output, SpvInstruction vector, SpvInstruction scale)
-        {
-            var vector2Type = context.TypeVector(context.TypeFP32(), 2);
-
-            var scaleNegated = context.FNegate(context.TypeFP32(), scale);
-            var scaleVector = context.CompositeConstruct(vector2Type, scaleNegated, scaleNegated);
-
-            var vectorFloat = context.ConvertSToF(vector2Type, vector);
-            var vectorScaled = context.VectorTimesScalar(vector2Type, vectorFloat, scaleNegated);
-
-            var fragCoordPointer = context.Inputs[new IoDefinition(StorageKind.Input, IoVariable.FragmentCoord)];
-            var fragCoord = context.Load(context.TypeVector(context.TypeFP32(), 4), fragCoordPointer);
-            var fragCoordXY = context.VectorShuffle(vector2Type, fragCoord, fragCoord, 0, 1);
-
-            var scaleMod = context.FMod(vector2Type, fragCoordXY, scaleVector);
-            var vectorInterpolated = context.FAdd(vector2Type, vectorScaled, scaleMod);
-
-            context.Store(output, context.ConvertFToS(context.TypeVector(context.TypeS32(), 2), vectorInterpolated));
-        }
-
-        private static void ApplyScalingNoInterpolation(CodeGenContext context, SpvInstruction output, SpvInstruction vector, SpvInstruction scale)
-        {
-            if (context.Config.Stage == ShaderStage.Vertex)
-            {
-                scale = context.GlslFAbs(context.TypeFP32(), scale);
-            }
-
-            var vector2Type = context.TypeVector(context.TypeFP32(), 2);
-
-            var vectorFloat = context.ConvertSToF(vector2Type, vector);
-            var vectorScaled = context.VectorTimesScalar(vector2Type, vectorFloat, scale);
-
-            context.Store(output, context.ConvertFToS(context.TypeVector(context.TypeS32(), 2), vectorScaled));
-        }
-
-        public static SpvInstruction ApplyUnscaling(
-            CodeGenContext context,
-            AstTextureOperation texOp,
-            SpvInstruction size,
-            bool isBindless,
-            bool isIndexed)
-        {
-            if (context.Config.Stage.SupportsRenderScale() &&
-                !isBindless &&
-                !isIndexed)
-            {
-                int index = context.Config.FindTextureDescriptorIndex(texOp);
-
-                var pointerType = context.TypePointer(StorageClass.Uniform, context.TypeFP32());
-                var fieldIndex = context.Constant(context.TypeU32(), 4);
-                var scaleIndex = context.Constant(context.TypeU32(), index);
-
-                if (context.Config.Stage == ShaderStage.Vertex)
-                {
-                    var scaleCountPointerType = context.TypePointer(StorageClass.Uniform, context.TypeS32());
-                    var scaleCountElemPointer = context.AccessChain(scaleCountPointerType, context.SupportBuffer, context.Constant(context.TypeU32(), 3));
-                    var scaleCount = context.Load(context.TypeS32(), scaleCountElemPointer);
-
-                    scaleIndex = context.IAdd(context.TypeU32(), scaleIndex, scaleCount);
-                }
-
-                scaleIndex = context.IAdd(context.TypeU32(), scaleIndex, context.Constant(context.TypeU32(), 1));
-
-                var scaleElemPointer = context.AccessChain(pointerType, context.SupportBuffer, fieldIndex, scaleIndex);
-                var scale = context.GlslFAbs(context.TypeFP32(), context.Load(context.TypeFP32(), scaleElemPointer));
-
-                var passthrough = context.FOrdEqual(context.TypeBool(), scale, context.Constant(context.TypeFP32(), 1f));
-
-                var sizeFloat = context.ConvertSToF(context.TypeFP32(), size);
-                var sizeUnscaled = context.FDiv(context.TypeFP32(), sizeFloat, scale);
-                var sizeUnscaledInt = context.ConvertFToS(context.TypeS32(), sizeUnscaled);
-
-                return context.Select(context.TypeS32(), passthrough, size, sizeUnscaledInt);
-            }
-
-            return size;
-        }
-    }
-}
\ No newline at end of file
diff --git a/Ryujinx.Graphics.Shader/CodeGen/Spirv/SpirvDelegates.cs b/Ryujinx.Graphics.Shader/CodeGen/Spirv/SpirvDelegates.cs
deleted file mode 100644
index 3ccfd7f5..00000000
--- a/Ryujinx.Graphics.Shader/CodeGen/Spirv/SpirvDelegates.cs
+++ /dev/null
@@ -1,226 +0,0 @@
-using FuncBinaryInstruction = System.Func<Spv.Generator.Instruction, Spv.Generator.Instruction, Spv.Generator.Instruction, Spv.Generator.Instruction>;
-using FuncQuaternaryInstruction = System.Func<Spv.Generator.Instruction, Spv.Generator.Instruction, Spv.Generator.Instruction, Spv.Generator.Instruction, Spv.Generator.Instruction, Spv.Generator.Instruction>;
-using FuncTernaryInstruction = System.Func<Spv.Generator.Instruction, Spv.Generator.Instruction, Spv.Generator.Instruction, Spv.Generator.Instruction, Spv.Generator.Instruction>;
-using FuncUnaryInstruction = System.Func<Spv.Generator.Instruction, Spv.Generator.Instruction, Spv.Generator.Instruction>;
-
-namespace Ryujinx.Graphics.Shader.CodeGen.Spirv
-{
-    /// <summary>
-    /// Delegate cache for SPIR-V instruction generators. Avoids delegate allocation when passing generators as arguments.
-    /// </summary>
-    internal readonly struct SpirvDelegates
-    {
-        // Unary
-        public readonly FuncUnaryInstruction GlslFAbs;
-        public readonly FuncUnaryInstruction GlslSAbs;
-        public readonly FuncUnaryInstruction GlslCeil;
-        public readonly FuncUnaryInstruction GlslCos;
-        public readonly FuncUnaryInstruction GlslExp2;
-        public readonly FuncUnaryInstruction GlslFloor;
-        public readonly FuncUnaryInstruction GlslLog2;
-        public readonly FuncUnaryInstruction FNegate;
-        public readonly FuncUnaryInstruction SNegate;
-        public readonly FuncUnaryInstruction GlslInverseSqrt;
-        public readonly FuncUnaryInstruction GlslRoundEven;
-        public readonly FuncUnaryInstruction GlslSin;
-        public readonly FuncUnaryInstruction GlslSqrt;
-        public readonly FuncUnaryInstruction GlslTrunc;
-
-        // UnaryBool
-        public readonly FuncUnaryInstruction LogicalNot;
-
-        // UnaryFP32
-        public readonly FuncUnaryInstruction DPdx;
-        public readonly FuncUnaryInstruction DPdy;
-
-        // UnaryS32
-        public readonly FuncUnaryInstruction BitCount;
-        public readonly FuncUnaryInstruction BitReverse;
-        public readonly FuncUnaryInstruction Not;
-
-        // Compare
-        public readonly FuncBinaryInstruction FOrdEqual;
-        public readonly FuncBinaryInstruction IEqual;
-        public readonly FuncBinaryInstruction FOrdGreaterThan;
-        public readonly FuncBinaryInstruction SGreaterThan;
-        public readonly FuncBinaryInstruction FOrdGreaterThanEqual;
-        public readonly FuncBinaryInstruction SGreaterThanEqual;
-        public readonly FuncBinaryInstruction FOrdLessThan;
-        public readonly FuncBinaryInstruction SLessThan;
-        public readonly FuncBinaryInstruction FOrdLessThanEqual;
-        public readonly FuncBinaryInstruction SLessThanEqual;
-        public readonly FuncBinaryInstruction FOrdNotEqual;
-        public readonly FuncBinaryInstruction INotEqual;
-
-        // CompareU32
-        public readonly FuncBinaryInstruction UGreaterThanEqual;
-        public readonly FuncBinaryInstruction UGreaterThan;
-        public readonly FuncBinaryInstruction ULessThanEqual;
-        public readonly FuncBinaryInstruction ULessThan;
-
-        // Binary
-        public readonly FuncBinaryInstruction FAdd;
-        public readonly FuncBinaryInstruction IAdd;
-        public readonly FuncBinaryInstruction FDiv;
-        public readonly FuncBinaryInstruction SDiv;
-        public readonly FuncBinaryInstruction GlslFMax;
-        public readonly FuncBinaryInstruction GlslSMax;
-        public readonly FuncBinaryInstruction GlslFMin;
-        public readonly FuncBinaryInstruction GlslSMin;
-        public readonly FuncBinaryInstruction FMul;
-        public readonly FuncBinaryInstruction IMul;
-        public readonly FuncBinaryInstruction FSub;
-        public readonly FuncBinaryInstruction ISub;
-
-        // BinaryBool
-        public readonly FuncBinaryInstruction LogicalAnd;
-        public readonly FuncBinaryInstruction LogicalNotEqual;
-        public readonly FuncBinaryInstruction LogicalOr;
-
-        // BinaryS32
-        public readonly FuncBinaryInstruction BitwiseAnd;
-        public readonly FuncBinaryInstruction BitwiseXor;
-        public readonly FuncBinaryInstruction BitwiseOr;
-        public readonly FuncBinaryInstruction ShiftLeftLogical;
-        public readonly FuncBinaryInstruction ShiftRightArithmetic;
-        public readonly FuncBinaryInstruction ShiftRightLogical;
-
-        // BinaryU32
-        public readonly FuncBinaryInstruction GlslUMax;
-        public readonly FuncBinaryInstruction GlslUMin;
-
-        // AtomicMemoryBinary
-        public readonly FuncQuaternaryInstruction AtomicIAdd;
-        public readonly FuncQuaternaryInstruction AtomicAnd;
-        public readonly FuncQuaternaryInstruction AtomicSMin;
-        public readonly FuncQuaternaryInstruction AtomicUMin;
-        public readonly FuncQuaternaryInstruction AtomicSMax;
-        public readonly FuncQuaternaryInstruction AtomicUMax;
-        public readonly FuncQuaternaryInstruction AtomicOr;
-        public readonly FuncQuaternaryInstruction AtomicExchange;
-        public readonly FuncQuaternaryInstruction AtomicXor;
-
-        // Ternary
-        public readonly FuncTernaryInstruction GlslFClamp;
-        public readonly FuncTernaryInstruction GlslSClamp;
-        public readonly FuncTernaryInstruction GlslFma;
-
-        // TernaryS32
-        public readonly FuncTernaryInstruction BitFieldSExtract;
-        public readonly FuncTernaryInstruction BitFieldUExtract;
-
-        // TernaryU32
-        public readonly FuncTernaryInstruction GlslUClamp;
-
-        // QuaternaryS32
-        public readonly FuncQuaternaryInstruction BitFieldInsert;
-
-        public SpirvDelegates(CodeGenContext context)
-        {
-            // Unary
-            GlslFAbs = context.GlslFAbs;
-            GlslSAbs = context.GlslSAbs;
-            GlslCeil = context.GlslCeil;
-            GlslCos = context.GlslCos;
-            GlslExp2 = context.GlslExp2;
-            GlslFloor = context.GlslFloor;
-            GlslLog2 = context.GlslLog2;
-            FNegate = context.FNegate;
-            SNegate = context.SNegate;
-            GlslInverseSqrt = context.GlslInverseSqrt;
-            GlslRoundEven = context.GlslRoundEven;
-            GlslSin = context.GlslSin;
-            GlslSqrt = context.GlslSqrt;
-            GlslTrunc = context.GlslTrunc;
-
-            // UnaryBool
-            LogicalNot = context.LogicalNot;
-
-            // UnaryFP32
-            DPdx = context.DPdx;
-            DPdy = context.DPdy;
-
-            // UnaryS32
-            BitCount = context.BitCount;
-            BitReverse = context.BitReverse;
-            Not = context.Not;
-
-            // Compare
-            FOrdEqual = context.FOrdEqual;
-            IEqual = context.IEqual;
-            FOrdGreaterThan = context.FOrdGreaterThan;
-            SGreaterThan = context.SGreaterThan;
-            FOrdGreaterThanEqual = context.FOrdGreaterThanEqual;
-            SGreaterThanEqual = context.SGreaterThanEqual;
-            FOrdLessThan = context.FOrdLessThan;
-            SLessThan = context.SLessThan;
-            FOrdLessThanEqual = context.FOrdLessThanEqual;
-            SLessThanEqual = context.SLessThanEqual;
-            FOrdNotEqual = context.FOrdNotEqual;
-            INotEqual = context.INotEqual;
-
-            // CompareU32
-            UGreaterThanEqual = context.UGreaterThanEqual;
-            UGreaterThan = context.UGreaterThan;
-            ULessThanEqual = context.ULessThanEqual;
-            ULessThan = context.ULessThan;
-
-            // Binary
-            FAdd = context.FAdd;
-            IAdd = context.IAdd;
-            FDiv = context.FDiv;
-            SDiv = context.SDiv;
-            GlslFMax = context.GlslFMax;
-            GlslSMax = context.GlslSMax;
-            GlslFMin = context.GlslFMin;
-            GlslSMin = context.GlslSMin;
-            FMul = context.FMul;
-            IMul = context.IMul;
-            FSub = context.FSub;
-            ISub = context.ISub;
-
-            // BinaryBool
-            LogicalAnd = context.LogicalAnd;
-            LogicalNotEqual = context.LogicalNotEqual;
-            LogicalOr = context.LogicalOr;
-
-            // BinaryS32
-            BitwiseAnd = context.BitwiseAnd;
-            BitwiseXor = context.BitwiseXor;
-            BitwiseOr = context.BitwiseOr;
-            ShiftLeftLogical = context.ShiftLeftLogical;
-            ShiftRightArithmetic = context.ShiftRightArithmetic;
-            ShiftRightLogical = context.ShiftRightLogical;
-
-            // BinaryU32
-            GlslUMax = context.GlslUMax;
-            GlslUMin = context.GlslUMin;
-
-            // AtomicMemoryBinary
-            AtomicIAdd = context.AtomicIAdd;
-            AtomicAnd = context.AtomicAnd;
-            AtomicSMin = context.AtomicSMin;
-            AtomicUMin = context.AtomicUMin;
-            AtomicSMax = context.AtomicSMax;
-            AtomicUMax = context.AtomicUMax;
-            AtomicOr = context.AtomicOr;
-            AtomicExchange = context.AtomicExchange;
-            AtomicXor = context.AtomicXor;
-
-            // Ternary
-            GlslFClamp = context.GlslFClamp;
-            GlslSClamp = context.GlslSClamp;
-            GlslFma = context.GlslFma;
-
-            // TernaryS32
-            BitFieldSExtract = context.BitFieldSExtract;
-            BitFieldUExtract = context.BitFieldUExtract;
-
-            // TernaryU32
-            GlslUClamp = context.GlslUClamp;
-
-            // QuaternaryS32
-            BitFieldInsert = context.BitFieldInsert;
-        }
-    }
-}
diff --git a/Ryujinx.Graphics.Shader/CodeGen/Spirv/SpirvGenerator.cs b/Ryujinx.Graphics.Shader/CodeGen/Spirv/SpirvGenerator.cs
deleted file mode 100644
index 3e11a974..00000000
--- a/Ryujinx.Graphics.Shader/CodeGen/Spirv/SpirvGenerator.cs
+++ /dev/null
@@ -1,415 +0,0 @@
-using Ryujinx.Common;
-using Ryujinx.Graphics.Shader.IntermediateRepresentation;
-using Ryujinx.Graphics.Shader.StructuredIr;
-using Ryujinx.Graphics.Shader.Translation;
-using System;
-using System.Collections.Generic;
-using static Spv.Specification;
-
-namespace Ryujinx.Graphics.Shader.CodeGen.Spirv
-{
-    using SpvInstruction = Spv.Generator.Instruction;
-    using SpvInstructionPool = Spv.Generator.GeneratorPool<Spv.Generator.Instruction>;
-    using SpvLiteralInteger = Spv.Generator.LiteralInteger;
-    using SpvLiteralIntegerPool = Spv.Generator.GeneratorPool<Spv.Generator.LiteralInteger>;
-
-    static class SpirvGenerator
-    {
-        // Resource pools for Spirv generation. Note: Increase count when more threads are being used.
-        private const int GeneratorPoolCount = 1;
-        private static ObjectPool<SpvInstructionPool> InstructionPool;
-        private static ObjectPool<SpvLiteralIntegerPool> IntegerPool;
-        private static object PoolLock;
-
-        static SpirvGenerator()
-        {
-            InstructionPool = new (() => new SpvInstructionPool(), GeneratorPoolCount);
-            IntegerPool = new (() => new SpvLiteralIntegerPool(), GeneratorPoolCount);
-            PoolLock = new object();
-        }
-
-        private const HelperFunctionsMask NeedsInvocationIdMask =
-            HelperFunctionsMask.Shuffle |
-            HelperFunctionsMask.ShuffleDown |
-            HelperFunctionsMask.ShuffleUp |
-            HelperFunctionsMask.ShuffleXor |
-            HelperFunctionsMask.SwizzleAdd;
-
-        public static byte[] Generate(StructuredProgramInfo info, ShaderConfig config)
-        {
-            SpvInstructionPool instPool;
-            SpvLiteralIntegerPool integerPool;
-
-            lock (PoolLock)
-            {
-                instPool = InstructionPool.Allocate();
-                integerPool = IntegerPool.Allocate();
-            }
-
-            CodeGenContext context = new CodeGenContext(info, config, instPool, integerPool);
-
-            context.AddCapability(Capability.GroupNonUniformBallot);
-            context.AddCapability(Capability.GroupNonUniformShuffle);
-            context.AddCapability(Capability.GroupNonUniformVote);
-            context.AddCapability(Capability.ImageBuffer);
-            context.AddCapability(Capability.ImageGatherExtended);
-            context.AddCapability(Capability.ImageQuery);
-            context.AddCapability(Capability.SampledBuffer);
-
-            if (config.TransformFeedbackEnabled && config.LastInVertexPipeline)
-            {
-                context.AddCapability(Capability.TransformFeedback);
-            }
-
-            if (config.Stage == ShaderStage.Fragment)
-            {
-                if (context.Info.IoDefinitions.Contains(new IoDefinition(StorageKind.Input, IoVariable.Layer)))
-                {
-                    context.AddCapability(Capability.Geometry);
-                }
-
-                if (context.Config.GpuAccessor.QueryHostSupportsFragmentShaderInterlock())
-                {
-                    context.AddCapability(Capability.FragmentShaderPixelInterlockEXT);
-                    context.AddExtension("SPV_EXT_fragment_shader_interlock");
-                }
-            }
-            else if (config.Stage == ShaderStage.Geometry)
-            {
-                context.AddCapability(Capability.Geometry);
-
-                if (config.GpPassthrough && context.Config.GpuAccessor.QueryHostSupportsGeometryShaderPassthrough())
-                {
-                    context.AddExtension("SPV_NV_geometry_shader_passthrough");
-                    context.AddCapability(Capability.GeometryShaderPassthroughNV);
-                }
-            }
-            else if (config.Stage == ShaderStage.TessellationControl || config.Stage == ShaderStage.TessellationEvaluation)
-            {
-                context.AddCapability(Capability.Tessellation);
-            }
-            else if (config.Stage == ShaderStage.Vertex)
-            {
-                context.AddCapability(Capability.DrawParameters);
-            }
-
-            if (context.Info.IoDefinitions.Contains(new IoDefinition(StorageKind.Output, IoVariable.ViewportMask)))
-            {
-                context.AddExtension("SPV_NV_viewport_array2");
-                context.AddCapability(Capability.ShaderViewportMaskNV);
-            }
-
-            if ((info.HelperFunctionsMask & NeedsInvocationIdMask) != 0)
-            {
-                info.IoDefinitions.Add(new IoDefinition(StorageKind.Input, IoVariable.SubgroupLaneId));
-            }
-
-            Declarations.DeclareAll(context, info);
-
-            for (int funcIndex = 0; funcIndex < info.Functions.Count; funcIndex++)
-            {
-                var function = info.Functions[funcIndex];
-                var retType = context.GetType(function.ReturnType);
-
-                var funcArgs = new SpvInstruction[function.InArguments.Length + function.OutArguments.Length];
-
-                for (int argIndex = 0; argIndex < funcArgs.Length; argIndex++)
-                {
-                    var argType = context.GetType(function.GetArgumentType(argIndex));
-                    var argPointerType = context.TypePointer(StorageClass.Function, argType);
-                    funcArgs[argIndex] = argPointerType;
-                }
-
-                var funcType = context.TypeFunction(retType, false, funcArgs);
-                var spvFunc = context.Function(retType, FunctionControlMask.MaskNone, funcType);
-
-                context.DeclareFunction(funcIndex, function, spvFunc);
-            }
-
-            for (int funcIndex = 0; funcIndex < info.Functions.Count; funcIndex++)
-            {
-                Generate(context, info, funcIndex);
-            }
-
-            byte[] result = context.Generate();
-
-            lock (PoolLock)
-            {
-                InstructionPool.Release(instPool);
-                IntegerPool.Release(integerPool);
-            }
-
-            return result;
-        }
-
-        private static void Generate(CodeGenContext context, StructuredProgramInfo info, int funcIndex)
-        {
-            var function = info.Functions[funcIndex];
-
-            (_, var spvFunc) = context.GetFunction(funcIndex);
-
-            context.AddFunction(spvFunc);
-            context.StartFunction();
-
-            Declarations.DeclareParameters(context, function);
-
-            context.EnterBlock(function.MainBlock);
-
-            Declarations.DeclareLocals(context, function);
-            Declarations.DeclareLocalForArgs(context, info.Functions);
-
-            Generate(context, function.MainBlock);
-
-            // Functions must always end with a return.
-            if (!(function.MainBlock.Last is AstOperation operation) ||
-                (operation.Inst != Instruction.Return && operation.Inst != Instruction.Discard))
-            {
-                context.Return();
-            }
-
-            context.FunctionEnd();
-
-            if (funcIndex == 0)
-            {
-                context.AddEntryPoint(context.Config.Stage.Convert(), spvFunc, "main", context.GetMainInterface());
-
-                if (context.Config.Stage == ShaderStage.TessellationControl)
-                {
-                    context.AddExecutionMode(spvFunc, ExecutionMode.OutputVertices, (SpvLiteralInteger)context.Config.ThreadsPerInputPrimitive);
-                }
-                else if (context.Config.Stage == ShaderStage.TessellationEvaluation)
-                {
-                    switch (context.Config.GpuAccessor.QueryTessPatchType())
-                    {
-                        case TessPatchType.Isolines:
-                            context.AddExecutionMode(spvFunc, ExecutionMode.Isolines);
-                            break;
-                        case TessPatchType.Triangles:
-                            context.AddExecutionMode(spvFunc, ExecutionMode.Triangles);
-                            break;
-                        case TessPatchType.Quads:
-                            context.AddExecutionMode(spvFunc, ExecutionMode.Quads);
-                            break;
-                    }
-
-                    switch (context.Config.GpuAccessor.QueryTessSpacing())
-                    {
-                        case TessSpacing.EqualSpacing:
-                            context.AddExecutionMode(spvFunc, ExecutionMode.SpacingEqual);
-                            break;
-                        case TessSpacing.FractionalEventSpacing:
-                            context.AddExecutionMode(spvFunc, ExecutionMode.SpacingFractionalEven);
-                            break;
-                        case TessSpacing.FractionalOddSpacing:
-                            context.AddExecutionMode(spvFunc, ExecutionMode.SpacingFractionalOdd);
-                            break;
-                    }
-
-                    bool tessCw = context.Config.GpuAccessor.QueryTessCw();
-
-                    if (context.Config.Options.TargetApi == TargetApi.Vulkan)
-                    {
-                        // We invert the front face on Vulkan backend, so we need to do that here as well.
-                        tessCw = !tessCw;
-                    }
-
-                    if (tessCw)
-                    {
-                        context.AddExecutionMode(spvFunc, ExecutionMode.VertexOrderCw);
-                    }
-                    else
-                    {
-                        context.AddExecutionMode(spvFunc, ExecutionMode.VertexOrderCcw);
-                    }
-                }
-                else if (context.Config.Stage == ShaderStage.Geometry)
-                {
-                    InputTopology inputTopology = context.Config.GpuAccessor.QueryPrimitiveTopology();
-
-                    context.AddExecutionMode(spvFunc, inputTopology switch
-                    {
-                        InputTopology.Points => ExecutionMode.InputPoints,
-                        InputTopology.Lines => ExecutionMode.InputLines,
-                        InputTopology.LinesAdjacency => ExecutionMode.InputLinesAdjacency,
-                        InputTopology.Triangles => ExecutionMode.Triangles,
-                        InputTopology.TrianglesAdjacency => ExecutionMode.InputTrianglesAdjacency,
-                        _ => throw new InvalidOperationException($"Invalid input topology \"{inputTopology}\".")
-                    });
-
-                    context.AddExecutionMode(spvFunc, ExecutionMode.Invocations, (SpvLiteralInteger)context.Config.ThreadsPerInputPrimitive);
-
-                    context.AddExecutionMode(spvFunc, context.Config.OutputTopology switch
-                    {
-                        OutputTopology.PointList => ExecutionMode.OutputPoints,
-                        OutputTopology.LineStrip => ExecutionMode.OutputLineStrip,
-                        OutputTopology.TriangleStrip => ExecutionMode.OutputTriangleStrip,
-                        _ => throw new InvalidOperationException($"Invalid output topology \"{context.Config.OutputTopology}\".")
-                    });
-
-                    int maxOutputVertices = context.Config.GpPassthrough ? context.InputVertices : context.Config.MaxOutputVertices;
-
-                    context.AddExecutionMode(spvFunc, ExecutionMode.OutputVertices, (SpvLiteralInteger)maxOutputVertices);
-                }
-                else if (context.Config.Stage == ShaderStage.Fragment)
-                {
-                    context.AddExecutionMode(spvFunc, context.Config.Options.TargetApi == TargetApi.Vulkan
-                        ? ExecutionMode.OriginUpperLeft
-                        : ExecutionMode.OriginLowerLeft);
-
-                    if (context.Info.IoDefinitions.Contains(new IoDefinition(StorageKind.Output, IoVariable.FragmentOutputDepth)))
-                    {
-                        context.AddExecutionMode(spvFunc, ExecutionMode.DepthReplacing);
-                    }
-
-                    if (context.Config.GpuAccessor.QueryEarlyZForce())
-                    {
-                        context.AddExecutionMode(spvFunc, ExecutionMode.EarlyFragmentTests);
-                    }
-
-                    if ((info.HelperFunctionsMask & HelperFunctionsMask.FSI) != 0 &&
-                        context.Config.GpuAccessor.QueryHostSupportsFragmentShaderInterlock())
-                    {
-                        context.AddExecutionMode(spvFunc, ExecutionMode.PixelInterlockOrderedEXT);
-                    }
-                }
-                else if (context.Config.Stage == ShaderStage.Compute)
-                {
-                    var localSizeX = (SpvLiteralInteger)context.Config.GpuAccessor.QueryComputeLocalSizeX();
-                    var localSizeY = (SpvLiteralInteger)context.Config.GpuAccessor.QueryComputeLocalSizeY();
-                    var localSizeZ = (SpvLiteralInteger)context.Config.GpuAccessor.QueryComputeLocalSizeZ();
-
-                    context.AddExecutionMode(
-                        spvFunc,
-                        ExecutionMode.LocalSize,
-                        localSizeX,
-                        localSizeY,
-                        localSizeZ);
-                }
-
-                if (context.Config.TransformFeedbackEnabled && context.Config.LastInVertexPipeline)
-                {
-                    context.AddExecutionMode(spvFunc, ExecutionMode.Xfb);
-                }
-            }
-        }
-
-        private static void Generate(CodeGenContext context, AstBlock block)
-        {
-            AstBlockVisitor visitor = new AstBlockVisitor(block);
-
-            var loopTargets = new Dictionary<AstBlock, (SpvInstruction, SpvInstruction)>();
-
-            context.LoopTargets = loopTargets;
-
-            visitor.BlockEntered += (sender, e) =>
-            {
-                AstBlock mergeBlock = e.Block.Parent;
-
-                if (e.Block.Type == AstBlockType.If)
-                {
-                    AstBlock ifTrueBlock = e.Block;
-                    AstBlock ifFalseBlock;
-
-                    if (AstHelper.Next(e.Block) is AstBlock nextBlock && nextBlock.Type == AstBlockType.Else)
-                    {
-                        ifFalseBlock = nextBlock;
-                    }
-                    else
-                    {
-                        ifFalseBlock = mergeBlock;
-                    }
-
-                    var condition = context.Get(AggregateType.Bool, e.Block.Condition);
-
-                    context.SelectionMerge(context.GetNextLabel(mergeBlock), SelectionControlMask.MaskNone);
-                    context.BranchConditional(condition, context.GetNextLabel(ifTrueBlock), context.GetNextLabel(ifFalseBlock));
-                }
-                else if (e.Block.Type == AstBlockType.DoWhile)
-                {
-                    var continueTarget = context.Label();
-
-                    loopTargets.Add(e.Block, (context.NewBlock(), continueTarget));
-
-                    context.LoopMerge(context.GetNextLabel(mergeBlock), continueTarget, LoopControlMask.MaskNone);
-                    context.Branch(context.GetFirstLabel(e.Block));
-                }
-
-                context.EnterBlock(e.Block);
-            };
-
-            visitor.BlockLeft += (sender, e) =>
-            {
-                if (e.Block.Parent != null)
-                {
-                    if (e.Block.Type == AstBlockType.DoWhile)
-                    {
-                        // This is a loop, we need to jump back to the loop header
-                        // if the condition is true.
-                        AstBlock mergeBlock = e.Block.Parent;
-
-                        (var loopTarget, var continueTarget) = loopTargets[e.Block];
-
-                        context.Branch(continueTarget);
-                        context.AddLabel(continueTarget);
-
-                        var condition = context.Get(AggregateType.Bool, e.Block.Condition);
-
-                        context.BranchConditional(condition, loopTarget, context.GetNextLabel(mergeBlock));
-                    }
-                    else
-                    {
-                        // We only need a branch if the last instruction didn't
-                        // already cause the program to exit or jump elsewhere.
-                        bool lastIsCf = e.Block.Last is AstOperation lastOp &&
-                            (lastOp.Inst == Instruction.Discard ||
-                             lastOp.Inst == Instruction.LoopBreak ||
-                             lastOp.Inst == Instruction.LoopContinue ||
-                             lastOp.Inst == Instruction.Return);
-
-                        if (!lastIsCf)
-                        {
-                            context.Branch(context.GetNextLabel(e.Block.Parent));
-                        }
-                    }
-
-                    bool hasElse = AstHelper.Next(e.Block) is AstBlock nextBlock &&
-                        (nextBlock.Type == AstBlockType.Else ||
-                         nextBlock.Type == AstBlockType.ElseIf);
-
-                    // Re-enter the parent block.
-                    if (e.Block.Parent != null && !hasElse)
-                    {
-                        context.EnterBlock(e.Block.Parent);
-                    }
-                }
-            };
-
-            foreach (IAstNode node in visitor.Visit())
-            {
-                if (node is AstAssignment assignment)
-                {
-                    var dest = (AstOperand)assignment.Destination;
-
-                    if (dest.Type == OperandType.LocalVariable)
-                    {
-                        var source = context.Get(dest.VarType, assignment.Source);
-                        context.Store(context.GetLocalPointer(dest), source);
-                    }
-                    else if (dest.Type == OperandType.Argument)
-                    {
-                        var source = context.Get(dest.VarType, assignment.Source);
-                        context.Store(context.GetArgumentPointer(dest), source);
-                    }
-                    else
-                    {
-                        throw new NotImplementedException(dest.Type.ToString());
-                    }
-                }
-                else if (node is AstOperation operation)
-                {
-                    Instructions.Generate(context, operation);
-                }
-            }
-        }
-    }
-}
diff --git a/Ryujinx.Graphics.Shader/CodeGen/Spirv/TextureMeta.cs b/Ryujinx.Graphics.Shader/CodeGen/Spirv/TextureMeta.cs
deleted file mode 100644
index 4de05603..00000000
--- a/Ryujinx.Graphics.Shader/CodeGen/Spirv/TextureMeta.cs
+++ /dev/null
@@ -1,4 +0,0 @@
-namespace Ryujinx.Graphics.Shader.CodeGen.Spirv
-{
-    readonly record struct TextureMeta(int CbufSlot, int Handle, TextureFormat Format);
-}
\ No newline at end of file