bsd: Fix Poll(0) returning ETIMEDOUT instead of SUCCESS

This was an oversight of the implementation.
sfdsnres: fix endianess issue for port serialisation
2022-09-01 21:46:11 +02:00 · 2022-09-01 21:31:20 +02:00 · 2022-08-31 21:33:03 +02:00 · 2022-08-31 21:33:03 +02:00 · 2022-08-28 14:24:19 +00:00 · 2022-08-28 01:56:26 +00:00
21 changed files with 1534 additions and 1348 deletions
--- a/ARMeilleure/Translation/IntervalTree.cs
+++ b/ARMeilleure/Translation/IntervalTree.cs
@@ -19,8 +19,6 @@ namespace ARMeilleure.Translation

        public int Count => _count;

-        public IntervalTree() { }
-
        #region Public Methods

        /// <summary>
--- a/Ryujinx.Ava/Assets/Locales/ja_JP.json
+++ b/Ryujinx.Ava/Assets/Locales/ja_JP.json
@@ -52,8 +52,8 @@
  "GameListContextMenuOpenModsDirectory": "Modディレクトリを開く",
  "GameListContextMenuOpenModsDirectoryToolTip": "アプリケーションの Mod データを格納するディレクトリを開きます",
  "GameListContextMenuCacheManagement": "キャッシュ管理",
-  "GameListContextMenuCacheManagementPurgePptc": "PPTC キャッシュを破棄",
-  "GameListContextMenuCacheManagementPurgePptcToolTip": "アプリケーションの PPTC キャッシュを破棄します",
+  "GameListContextMenuCacheManagementPurgePptc": "PPTC を再構築",
+  "GameListContextMenuCacheManagementPurgePptcToolTip": "次回のゲーム起動時に PPTC を再構築します",
  "GameListContextMenuCacheManagementPurgeShaderCache": "シェーダキャッシュを破棄",
  "GameListContextMenuCacheManagementPurgeShaderCacheToolTip": "アプリケーションのシェーダキャッシュを破棄します",
  "GameListContextMenuCacheManagementOpenPptcDirectory": "PPTC ディレクトリを開く",
@@ -121,9 +121,9 @@
  "SettingsTabSystemHacksNote": " (挙動が不安定になる可能性があります)",
  "SettingsTabSystemExpandDramSize": "DRAMサイズを6GBに拡大",
  "SettingsTabSystemIgnoreMissingServices": "未実装サービスを無視",
-  "SettingsTabGraphics": "グラフィクス",
-  "SettingsTabGraphicsEnhancements": "拡張",
-  "SettingsTabGraphicsEnableShaderCache": "シェーダキャッシュ",
+  "SettingsTabGraphics": "グラフィックス",
+  "SettingsTabGraphicsAPI": "グラフィックスAPI",
+  "SettingsTabGraphicsEnableShaderCache": "シェーダキャッシュを有効",
  "SettingsTabGraphicsAnisotropicFiltering": "異方性フィルタリング:",
  "SettingsTabGraphicsAnisotropicFilteringAuto": "自動",
  "SettingsTabGraphicsAnisotropicFiltering2x": "2x",
@@ -144,7 +144,7 @@
  "SettingsTabGraphicsAspectRatio32x9": "32:9",
  "SettingsTabGraphicsAspectRatioStretch": "ウインドウサイズに合わせる",
  "SettingsTabGraphicsDeveloperOptions": "開発者向けオプション",
-  "SettingsTabGraphicsShaderDumpPath": "グラフィクス シェーダダンプパス:",
+  "SettingsTabGraphicsShaderDumpPath": "グラフィックス シェーダダンプパス:",
  "SettingsTabLogging": "ロギング",
  "SettingsTabLoggingLogging": "ロギング",
  "SettingsTabLoggingEnableLoggingToFile": "ファイルへのロギングを有効",
@@ -350,7 +350,7 @@
  "DialogProfileDeleteProfileTitle": "プロファイルを削除中",
  "DialogProfileDeleteProfileMessage": "このアクションは元に戻せません. 本当に続けてよろしいですか?",
  "DialogWarning": "警告",
-  "DialogPPTCDeletionMessage": "PPTC キャッシュを破棄しようとしています:\n\n{0}\n\n実行してよろしいですか?",
+  "DialogPPTCDeletionMessage": "次回起動時に PPTC を再構築します:\n\n{0}\n\n実行してよろしいですか?",
  "DialogPPTCDeletionErrorMessage": "PPTC キャッシュ破棄エラー {0}: {1}",
  "DialogShaderDeletionMessage": "シェーダキャッシュを破棄しようとしています:\n\n{0}\n\n実行してよろしいですか?",
  "DialogShaderDeletionErrorMessage": "シェーダキャッシュ破棄エラー {0}: {1}",
@@ -379,7 +379,7 @@
  "DialogSettingsBackendThreadingWarningTitle": "警告 - バックエンドスレッディング",
  "DialogSettingsBackendThreadingWarningMessage": "このオプションの変更を完全に適用するには Ryujinx の再起動が必要です. プラットフォームによっては, Ryujinx のものを使用する前に手動でドライバ自身のマルチスレッディングを無効にする必要があるかもしれません.",
  "SettingsTabGraphicsFeaturesOptions": "機能",
-  "SettingsTabGraphicsBackendMultithreading": "グラフィクスバックエンドのマルチスレッド実行:",
+  "SettingsTabGraphicsBackendMultithreading": "グラフィックスバックエンドのマルチスレッド実行:",
  "CommonAuto": "自動",
  "CommonOff": "オフ",
  "CommonOn": "オン",
@@ -425,7 +425,7 @@
  "CustomThemeCheckTooltip": "エミュレータのメニュー外観を変更するためカスタム Avalonia テーマを使用します",
  "CustomThemePathTooltip": "カスタム GUI テーマのパスです",
  "CustomThemeBrowseTooltip": "カスタム GUI テーマを参照します",
-  "DockModeToggleTooltip": "有効にすると,ドッキングされた Nintendo Switch をエミュレートします.多くのゲームではグラフィクス品質が向上します.\n無効にすると,携帯モードの Nintendo Switch をエミュレートします.グラフィクスの品質は低下します.\n\nドッキングモード有効ならプレイヤー1の,無効なら携帯の入力を設定してください.\n\nよくわからない場合はオンのままにしてください.",
+  "DockModeToggleTooltip": "有効にすると,ドッキングされた Nintendo Switch をエミュレートします.多くのゲームではグラフィックス品質が向上します.\n無効にすると,携帯モードの Nintendo Switch をエミュレートします.グラフィックスの品質は低下します.\n\nドッキングモード有効ならプレイヤー1の,無効なら携帯の入力を設定してください.\n\nよくわからない場合はオンのままにしてください.",
  "DirectKeyboardTooltip": "キーボード直接アクセス (HID) に対応します. キーボードをテキスト入力デバイスとして使用できます.",
  "DirectMouseTooltip": "マウス直接アクセス (HID) に対応します. マウスをポインティングデバイスとして使用できます.",
  "RegionTooltip": "システムの地域を変更します",
@@ -442,14 +442,14 @@
  "MemoryManagerUnsafeTooltip": "メモリを直接マップしますが, アクセス前にゲストのアドレス空間内のアドレスをマスクしません. より高速になりますが, 安全性が犠牲になります. ゲストアプリケーションは Ryujinx のどこからでもメモリにアクセスできるので,このモードでは信頼できるプログラムだけを実行するようにしてください.",
  "DRamTooltip": "エミュレートされたシステムのメモリ容量を 4GB から 6GB に増加します.\n\n高解像度のテクスチャパックや 4K解像度の mod を使用する場合に有用です. パフォーマンスを改善するものではありません.\n\nよくわからない場合はオフのままにしてください.",
  "IgnoreMissingServicesTooltip": "未実装の Horizon OS サービスを無視します. 特定のゲームにおいて起動時のクラッシュを回避できる場合があります.\n\nよくわからない場合はオフのままにしてください.",
-  "GraphicsBackendThreadingTooltip": "グラフィクスバックエンドのコマンドを別スレッドで実行します.\n\nシェーダのコンパイルを高速化し, 遅延を軽減し, マルチスレッド非対応の GPU ドライバにおいてパフォーマンスを改善します. マルチスレッド対応のドライバでも若干パフォーマンス改善が見られます.\n\nよくわからない場合は自動に設定してください.",
-  "GalThreadingTooltip": "グラフィクスバックエンドのコマンドを別スレッドで実行します.\n\nシェーダのコンパイルを高速化し, 遅延を軽減し, マルチスレッド非対応の GPU ドライバにおいてパフォーマンスを改善します. マルチスレッド対応のドライバでも若干パフォーマンス改善が見られます.\n\nよくわからない場合は自動に設定してください.",
+  "GraphicsBackendThreadingTooltip": "グラフィックスバックエンドのコマンドを別スレッドで実行します.\n\nシェーダのコンパイルを高速化し, 遅延を軽減し, マルチスレッド非対応の GPU ドライバにおいてパフォーマンスを改善します. マルチスレッド対応のドライバでも若干パフォーマンス改善が見られます.\n\nよくわからない場合は自動に設定してください.",
+  "GalThreadingTooltip": "グラフィックスバックエンドのコマンドを別スレッドで実行します.\n\nシェーダのコンパイルを高速化し, 遅延を軽減し, マルチスレッド非対応の GPU ドライバにおいてパフォーマンスを改善します. マルチスレッド対応のドライバでも若干パフォーマンス改善が見られます.\n\nよくわからない場合は自動に設定してください.",
  "ShaderCacheToggleTooltip": "ディスクシェーダキャッシュをセーブし,次回以降の実行時遅延を軽減します.\n\nよくわからない場合はオンのままにしてください.",
  "ResolutionScaleTooltip": "レンダリングに適用される解像度の倍率です",
  "ResolutionScaleEntryTooltip": "1.5 のような整数でない倍率を指定すると,問題が発生したりクラッシュしたりする場合があります.",
  "AnisotropyTooltip": "異方性フィルタリングのレベルです (ゲームが要求する値を使用する場合は｢自動｣を設定してください)",
  "AspectRatioTooltip": "レンダリングに適用されるアスペクト比です.",
-  "ShaderDumpPathTooltip": "グラフィクス シェーダダンプのパスです",
+  "ShaderDumpPathTooltip": "グラフィックス シェーダダンプのパスです",
  "FileLogTooltip": "コンソール出力されるログをディスク上のログファイルにセーブします. パフォーマンスには影響を与えません.",
  "StubLogTooltip": "stub ログメッセージをコンソールに出力します. パフォーマンスには影響を与えません.",
  "InfoLogTooltip": "info ログメッセージをコンソールに出力します. パフォーマンスには影響を与えません.",
@@ -539,7 +539,7 @@
  "LoadingHeading": "ロード中: {0}",
  "CompilingPPTC": "PTC をコンパイル中",
  "CompilingShaders": "シェーダをコンパイル中",
-  "AllKeyboards": "すべてキーボード",
+  "AllKeyboards": "すべてのキーボード",
  "OpenFileDialogTitle": "開くファイルを選択",
  "OpenFolderDialogTitle": "展開されたゲームフォルダを選択",
  "AllSupportedFormats": "すべての対応フォーマット",
@@ -573,9 +573,20 @@
  "Save": "セーブ",
  "Discard": "破棄",
  "UserProfilesSetProfileImage": "プロファイル画像を設定",
-  "UserProfileEmptyNameError": "名前が必要です",
+  "UserProfileEmptyNameError": "名称が必要です",
  "UserProfileNoImageError":  "プロファイル画像が必要です",
  "GameUpdateWindowHeading": "利用可能なアップデート {0} [{1}]",
  "SettingsTabHotkeysResScaleUpHotkey": "解像度を上げる:",
-  "SettingsTabHotkeysResScaleDownHotkey": "解像度を下げる:"
+  "SettingsTabHotkeysResScaleDownHotkey": "解像度を下げる:",
+  "UserProfilesName": "名称:",
+  "UserProfilesUserId" : "ユーザID:",
+  "SettingsTabGraphicsBackend": "グラフィックスバックエンド",
+  "SettingsTabGraphicsBackendTooltip": "使用するグラフィックスバックエンドです",
+  "SettingsEnableTextureRecompression": "テクスチャの再圧縮を有効",
+  "SettingsEnableTextureRecompressionTooltip": "VRAMの使用量を削減するためテクスチャを圧縮します.\n\nGPUのVRAMが4GB未満の場合は使用を推奨します.\n\nよくわからない場合はオフのままにしてください.",
+  "SettingsTabGraphicsPreferredGpu": "優先使用するGPU",
+  "SettingsTabGraphicsPreferredGpuTooltip": "Vulkanグラフィックスバックエンドで使用されるグラフィックスカードを選択します.\n\nOpenGLが使用するGPUには影響しません.\n\n不明な場合は, \"dGPU\" としてフラグが立っているGPUに設定します. ない場合はそのままにします.",
+  "SettingsAppRequiredRestartMessage": "Ryujinx の再起動が必要です",
+  "SettingsGpuBackendRestartMessage": "グラフィックスバックエンドまたはGPUの設定が変更されました. 変更を適用するには再起動する必要があります",
+  "SettingsGpuBackendRestartSubMessage": "今すぐ再起動しますか?"
 }
--- a/Ryujinx.Common/Collections/IntervalTree.cs
+++ b/Ryujinx.Common/Collections/IntervalTree.cs
@@ -9,19 +9,10 @@ namespace Ryujinx.Common.Collections
    /// </summary>
    /// <typeparam name="K">Key</typeparam>
    /// <typeparam name="V">Value</typeparam>
-    public class IntervalTree<K, V> where K : IComparable<K>
+    public class IntervalTree<K, V> : IntrusiveRedBlackTreeImpl<IntervalTreeNode<K, V>> where K : IComparable<K>
    {
        private const int ArrayGrowthSize = 32;

-        private const bool Black = true;
-        private const bool Red = false;
-        private IntervalTreeNode<K, V> _root = null;
-        private int _count = 0;
-
-        public int Count => _count;
-
-        public IntervalTree() { }
-
        #region Public Methods

        /// <summary>
@@ -80,7 +71,7 @@ namespace Ryujinx.Common.Collections
                throw new ArgumentNullException(nameof(end));
            }

-            GetValues(_root, start, end, ref overlaps, ref overlapCount);
+            GetValues(Root, start, end, ref overlaps, ref overlapCount);

            return overlapCount;
        }
@@ -128,7 +119,7 @@ namespace Ryujinx.Common.Collections

            int removed = Delete(key, value);

-            _count -= removed;
+            Count -= removed;

            return removed;
        }
@@ -141,7 +132,7 @@ namespace Ryujinx.Common.Collections
        {
            List<RangeNode<K, V>> list = new List<RangeNode<K, V>>();

-            AddToList(_root, list);
+            AddToList(Root, list);

            return list;
        }
@@ -182,7 +173,7 @@ namespace Ryujinx.Common.Collections
                throw new ArgumentNullException(nameof(key));
            }

-            IntervalTreeNode<K, V> node = _root;
+            IntervalTreeNode<K, V> node = Root;
            while (node != null)
            {
                int cmp = key.CompareTo(node.Start);
@@ -317,7 +308,7 @@ namespace Ryujinx.Common.Collections
        private IntervalTreeNode<K, V> BSTInsert(K start, K end, V value)
        {
            IntervalTreeNode<K, V> parent = null;
-            IntervalTreeNode<K, V> node = _root;
+            IntervalTreeNode<K, V> node = Root;

            while (node != null)
            {
@@ -345,14 +336,14 @@ namespace Ryujinx.Common.Collections
                        }
                    }

-                    _count++;
+                    Count++;
                    return node;
                }
            }
            IntervalTreeNode<K, V> newNode = new IntervalTreeNode<K, V>(start, end, value, parent);
            if (newNode.Parent == null)
            {
-                _root = newNode;
+                Root = newNode;
            }
            else if (start.CompareTo(parent.Start) < 0)
            {
@@ -364,7 +355,7 @@ namespace Ryujinx.Common.Collections
            }

            PropagateIncrease(newNode);
-            _count++;
+            Count++;
            return newNode;
        }

@@ -418,7 +409,7 @@ namespace Ryujinx.Common.Collections

            if (ParentOf(replacementNode) == null)
            {
-                _root = tmp;
+                Root = tmp;
            }
            else if (replacementNode == LeftOf(ParentOf(replacementNode)))
            {
@@ -447,295 +438,27 @@ namespace Ryujinx.Common.Collections
            return removed;
        }

-        /// <summary>
-        /// Returns the node with the largest key where <paramref name="node"/> is considered the root node.
-        /// </summary>
-        /// <param name="node">Root Node</param>
-        /// <returns>Node with the maximum key in the tree of <paramref name="node"/></returns>
-        private static IntervalTreeNode<K, V> Maximum(IntervalTreeNode<K, V> node)
-        {
-            IntervalTreeNode<K, V> tmp = node;
-            while (tmp.Right != null)
-            {
-                tmp = tmp.Right;
-            }
-
-            return tmp;
-        }
-
-        /// <summary>
-        /// Finds the node whose key is immediately less than <paramref name="node"/>.
-        /// </summary>
-        /// <param name="node">Node to find the predecessor of</param>
-        /// <returns>Predecessor of <paramref name="node"/></returns>
-        private static IntervalTreeNode<K, V> PredecessorOf(IntervalTreeNode<K, V> node)
-        {
-            if (node.Left != null)
-            {
-                return Maximum(node.Left);
-            }
-            IntervalTreeNode<K, V> parent = node.Parent;
-            while (parent != null && node == parent.Left)
-            {
-                node = parent;
-                parent = parent.Parent;
-            }
-            return parent;
-        }
        #endregion

-        #region Private Methods (RBL)
-        private void RestoreBalanceAfterRemoval(IntervalTreeNode<K, V> balanceNode)
-        {
-            IntervalTreeNode<K, V> ptr = balanceNode;
-
-            while (ptr != _root && ColorOf(ptr) == Black)
-            {
-                if (ptr == LeftOf(ParentOf(ptr)))
-                {
-                    IntervalTreeNode<K, V> sibling = RightOf(ParentOf(ptr));
-
-                    if (ColorOf(sibling) == Red)
-                    {
-                        SetColor(sibling, Black);
-                        SetColor(ParentOf(ptr), Red);
-                        RotateLeft(ParentOf(ptr));
-                        sibling = RightOf(ParentOf(ptr));
-                    }
-                    if (ColorOf(LeftOf(sibling)) == Black && ColorOf(RightOf(sibling)) == Black)
-                    {
-                        SetColor(sibling, Red);
-                        ptr = ParentOf(ptr);
-                    }
-                    else
-                    {
-                        if (ColorOf(RightOf(sibling)) == Black)
-                        {
-                            SetColor(LeftOf(sibling), Black);
-                            SetColor(sibling, Red);
-                            RotateRight(sibling);
-                            sibling = RightOf(ParentOf(ptr));
-                        }
-                        SetColor(sibling, ColorOf(ParentOf(ptr)));
-                        SetColor(ParentOf(ptr), Black);
-                        SetColor(RightOf(sibling), Black);
-                        RotateLeft(ParentOf(ptr));
-                        ptr = _root;
-                    }
-                }
-                else
-                {
-                    IntervalTreeNode<K, V> sibling = LeftOf(ParentOf(ptr));
-
-                    if (ColorOf(sibling) == Red)
-                    {
-                        SetColor(sibling, Black);
-                        SetColor(ParentOf(ptr), Red);
-                        RotateRight(ParentOf(ptr));
-                        sibling = LeftOf(ParentOf(ptr));
-                    }
-                    if (ColorOf(RightOf(sibling)) == Black && ColorOf(LeftOf(sibling)) == Black)
-                    {
-                        SetColor(sibling, Red);
-                        ptr = ParentOf(ptr);
-                    }
-                    else
-                    {
-                        if (ColorOf(LeftOf(sibling)) == Black)
-                        {
-                            SetColor(RightOf(sibling), Black);
-                            SetColor(sibling, Red);
-                            RotateLeft(sibling);
-                            sibling = LeftOf(ParentOf(ptr));
-                        }
-                        SetColor(sibling, ColorOf(ParentOf(ptr)));
-                        SetColor(ParentOf(ptr), Black);
-                        SetColor(LeftOf(sibling), Black);
-                        RotateRight(ParentOf(ptr));
-                        ptr = _root;
-                    }
-                }
-            }
-            SetColor(ptr, Black);
-        }
-
-        private void RestoreBalanceAfterInsertion(IntervalTreeNode<K, V> balanceNode)
-        {
-            SetColor(balanceNode, Red);
-            while (balanceNode != null && balanceNode != _root && ColorOf(ParentOf(balanceNode)) == Red)
-            {
-                if (ParentOf(balanceNode) == LeftOf(ParentOf(ParentOf(balanceNode))))
-                {
-                    IntervalTreeNode<K, V> sibling = RightOf(ParentOf(ParentOf(balanceNode)));
-
-                    if (ColorOf(sibling) == Red)
-                    {
-                        SetColor(ParentOf(balanceNode), Black);
-                        SetColor(sibling, Black);
-                        SetColor(ParentOf(ParentOf(balanceNode)), Red);
-                        balanceNode = ParentOf(ParentOf(balanceNode));
-                    }
-                    else
-                    {
-                        if (balanceNode == RightOf(ParentOf(balanceNode)))
-                        {
-                            balanceNode = ParentOf(balanceNode);
-                            RotateLeft(balanceNode);
-                        }
-                        SetColor(ParentOf(balanceNode), Black);
-                        SetColor(ParentOf(ParentOf(balanceNode)), Red);
-                        RotateRight(ParentOf(ParentOf(balanceNode)));
-                    }
-                }
-                else
-                {
-                    IntervalTreeNode<K, V> sibling = LeftOf(ParentOf(ParentOf(balanceNode)));
-
-                    if (ColorOf(sibling) == Red)
-                    {
-                        SetColor(ParentOf(balanceNode), Black);
-                        SetColor(sibling, Black);
-                        SetColor(ParentOf(ParentOf(balanceNode)), Red);
-                        balanceNode = ParentOf(ParentOf(balanceNode));
-                    }
-                    else
-                    {
-                        if (balanceNode == LeftOf(ParentOf(balanceNode)))
-                        {
-                            balanceNode = ParentOf(balanceNode);
-                            RotateRight(balanceNode);
-                        }
-                        SetColor(ParentOf(balanceNode), Black);
-                        SetColor(ParentOf(ParentOf(balanceNode)), Red);
-                        RotateLeft(ParentOf(ParentOf(balanceNode)));
-                    }
-                }
-            }
-            SetColor(_root, Black);
-        }
-
-        private void RotateLeft(IntervalTreeNode<K, V> node)
+        protected override void RotateLeft(IntervalTreeNode<K, V> node)
        {
            if (node != null)
            {
-                IntervalTreeNode<K, V> right = RightOf(node);
-                node.Right = LeftOf(right);
-                if (node.Right != null)
-                {
-                    node.Right.Parent = node;
-                }
-                IntervalTreeNode<K, V> nodeParent = ParentOf(node);
-                right.Parent = nodeParent;
-                if (nodeParent == null)
-                {
-                    _root = right;
-                }
-                else if (node == LeftOf(nodeParent))
-                {
-                    nodeParent.Left = right;
-                }
-                else
-                {
-                    nodeParent.Right = right;
-                }
-                right.Left = node;
-                node.Parent = right;
+                base.RotateLeft(node);

                PropagateFull(node);
            }
        }

-        private void RotateRight(IntervalTreeNode<K, V> node)
+        protected override void RotateRight(IntervalTreeNode<K, V> node)
        {
            if (node != null)
            {
-                IntervalTreeNode<K, V> left = LeftOf(node);
-                node.Left = RightOf(left);
-                if (node.Left != null)
-                {
-                    node.Left.Parent = node;
-                }
-                IntervalTreeNode<K, V> nodeParent = ParentOf(node);
-                left.Parent = nodeParent;
-                if (nodeParent == null)
-                {
-                    _root = left;
-                }
-                else if (node == RightOf(nodeParent))
-                {
-                    nodeParent.Right = left;
-                }
-                else
-                {
-                    nodeParent.Left = left;
-                }
-                left.Right = node;
-                node.Parent = left;
+                base.RotateRight(node);

                PropagateFull(node);
            }
        }
-        #endregion
-
-        #region Safety-Methods
-
-        // These methods save memory by allowing us to forego sentinel nil nodes, as well as serve as protection against NullReferenceExceptions.
-
-        /// <summary>
-        /// Returns the color of <paramref name="node"/>, or Black if it is null.
-        /// </summary>
-        /// <param name="node">Node</param>
-        /// <returns>The boolean color of <paramref name="node"/>, or black if null</returns>
-        private static bool ColorOf(IntervalTreeNode<K, V> node)
-        {
-            return node == null || node.Color;
-        }
-
-        /// <summary>
-        /// Sets the color of <paramref name="node"/> node to <paramref name="color"/>.
-        /// <br></br>
-        /// This method does nothing if <paramref name="node"/> is null.
-        /// </summary>
-        /// <param name="node">Node to set the color of</param>
-        /// <param name="color">Color (Boolean)</param>
-        private static void SetColor(IntervalTreeNode<K, V> node, bool color)
-        {
-            if (node != null)
-            {
-                node.Color = color;
-            }
-        }
-
-        /// <summary>
-        /// This method returns the left node of <paramref name="node"/>, or null if <paramref name="node"/> is null.
-        /// </summary>
-        /// <param name="node">Node to retrieve the left child from</param>
-        /// <returns>Left child of <paramref name="node"/></returns>
-        private static IntervalTreeNode<K, V> LeftOf(IntervalTreeNode<K, V> node)
-        {
-            return node?.Left;
-        }
-
-        /// <summary>
-        /// This method returns the right node of <paramref name="node"/>, or null if <paramref name="node"/> is null.
-        /// </summary>
-        /// <param name="node">Node to retrieve the right child from</param>
-        /// <returns>Right child of <paramref name="node"/></returns>
-        private static IntervalTreeNode<K, V> RightOf(IntervalTreeNode<K, V> node)
-        {
-            return node?.Right;
-        }
-
-        /// <summary>
-        /// Returns the parent node of <paramref name="node"/>, or null if <paramref name="node"/> is null.
-        /// </summary>
-        /// <param name="node">Node to retrieve the parent from</param>
-        /// <returns>Parent of <paramref name="node"/></returns>
-        private static IntervalTreeNode<K, V> ParentOf(IntervalTreeNode<K, V> node)
-        {
-            return node?.Parent;
-        }
-        #endregion

        public bool ContainsKey(K key)
        {
@@ -745,12 +468,6 @@ namespace Ryujinx.Common.Collections
            }
            return GetNode(key) != null;
        }
-
-        public void Clear()
-        {
-            _root = null;
-            _count = 0;
-        }
    }

    /// <summary>
@@ -777,31 +494,29 @@ namespace Ryujinx.Common.Collections
    /// </summary>
    /// <typeparam name="K">Key type of the node</typeparam>
    /// <typeparam name="V">Value type of the node</typeparam>
-    class IntervalTreeNode<K, V>
+    public class IntervalTreeNode<K, V> : IntrusiveRedBlackTreeNode<IntervalTreeNode<K, V>>
    {
-        public bool Color = true;
-        public IntervalTreeNode<K, V> Left = null;
-        public IntervalTreeNode<K, V> Right = null;
-        public IntervalTreeNode<K, V> Parent = null;
-
        /// <summary>
        /// The start of the range.
        /// </summary>
-        public K Start;
+        internal K Start;

        /// <summary>
        /// The end of the range - maximum of all in the Values list.
        /// </summary>
-        public K End;
+        internal K End;

        /// <summary>
        /// The maximum end value of this node and all its children.
        /// </summary>
-        public K Max;
+        internal K Max;

-        public List<RangeNode<K, V>> Values;
+        /// <summary>
+        /// Values contained on the node that shares a common Start value.
+        /// </summary>
+        internal List<RangeNode<K, V>> Values;

-        public IntervalTreeNode(K start, K end, V value, IntervalTreeNode<K, V> parent)
+        internal IntervalTreeNode(K start, K end, V value, IntervalTreeNode<K, V> parent)
        {
            Start = start;
            End = end;
--- a/Ryujinx.Common/Collections/IntrusiveRedBlackTree.cs
+++ b/Ryujinx.Common/Collections/IntrusiveRedBlackTree.cs
@@ -0,0 +1,293 @@
+using System;
+
+namespace Ryujinx.Common.Collections
+{
+    /// <summary>
+    /// Tree that provides the ability for O(logN) lookups for keys that exist in the tree, and O(logN) lookups for keys immediately greater than or less than a specified key.
+    /// </summary>
+    /// <typeparam name="T">Derived node type</typeparam>
+    public class IntrusiveRedBlackTree<T> : IntrusiveRedBlackTreeImpl<T> where T : IntrusiveRedBlackTreeNode<T>, IComparable<T>
+    {
+        #region Public Methods
+
+        /// <summary>
+        /// Adds a new node into the tree.
+        /// </summary>
+        /// <param name="node">Node to be added</param>
+        /// <exception cref="ArgumentNullException"><paramref name="node"/> is null</exception>
+        public void Add(T node)
+        {
+            if (node == null)
+            {
+                throw new ArgumentNullException(nameof(node));
+            }
+
+            Insert(node);
+        }
+
+        /// <summary>
+        /// Removes a node from the tree.
+        /// </summary>
+        /// <param name="node">Note to be removed</param>
+        /// <exception cref="ArgumentNullException"><paramref name="node"/> is null</exception>
+        public void Remove(T node)
+        {
+            if (node == null)
+            {
+                throw new ArgumentNullException(nameof(node));
+            }
+            if (Delete(node) != null)
+            {
+                Count--;
+            }
+        }
+
+        /// <summary>
+        /// Retrieve the node that is considered equal to the specified node by the comparator.
+        /// </summary>
+        /// <param name="searchNode">Node to compare with</param>
+        /// <returns>Node that is equal to <paramref name="searchNode"/></returns>
+        /// <exception cref="ArgumentNullException"><paramref name="searchNode"/> is null</exception>
+        public T GetNode(T searchNode)
+        {
+            if (searchNode == null)
+            {
+                throw new ArgumentNullException(nameof(searchNode));
+            }
+
+            T node = Root;
+            while (node != null)
+            {
+                int cmp = searchNode.CompareTo(node);
+                if (cmp < 0)
+                {
+                    node = node.Left;
+                }
+                else if (cmp > 0)
+                {
+                    node = node.Right;
+                }
+                else
+                {
+                    return node;
+                }
+            }
+            return null;
+        }
+
+        #endregion
+
+        #region Private Methods (BST)
+
+        /// <summary>
+        /// Inserts a new node into the tree.
+        /// </summary>
+        /// <param name="node">Node to be inserted</param>
+        private void Insert(T node)
+        {
+            T newNode = BSTInsert(node);
+            RestoreBalanceAfterInsertion(newNode);
+        }
+
+        /// <summary>
+        /// Insertion Mechanism for a Binary Search Tree (BST).
+        /// <br></br>
+        /// Iterates the tree starting from the root and inserts a new node
+        /// where all children in the left subtree are less than <paramref name="newNode"/>,
+        /// and all children in the right subtree are greater than <paramref name="newNode"/>.
+        /// </summary>
+        /// <param name="newNode">Node to be inserted</param>
+        /// <returns>The inserted Node</returns>
+        private T BSTInsert(T newNode)
+        {
+            T parent = null;
+            T node = Root;
+
+            while (node != null)
+            {
+                parent = node;
+                int cmp = newNode.CompareTo(node);
+                if (cmp < 0)
+                {
+                    node = node.Left;
+                }
+                else if (cmp > 0)
+                {
+                    node = node.Right;
+                }
+                else
+                {
+                    return node;
+                }
+            }
+            newNode.Parent = parent;
+            if (parent == null)
+            {
+                Root = newNode;
+            }
+            else if (newNode.CompareTo(parent) < 0)
+            {
+                parent.Left = newNode;
+            }
+            else
+            {
+                parent.Right = newNode;
+            }
+            Count++;
+            return newNode;
+        }
+
+        /// <summary>
+        /// Removes <paramref name="nodeToDelete"/> from the tree, if it exists.
+        /// </summary>
+        /// <param name="nodeToDelete">Node to be removed</param>
+        /// <returns>The deleted Node</returns>
+        private T Delete(T nodeToDelete)
+        {
+            if (nodeToDelete == null)
+            {
+                return null;
+            }
+
+            T old = nodeToDelete;
+            T child;
+            T parent;
+            bool color;
+
+            if (LeftOf(nodeToDelete) == null)
+            {
+                child = RightOf(nodeToDelete);
+            }
+            else if (RightOf(nodeToDelete) == null)
+            {
+                child = LeftOf(nodeToDelete);
+            }
+            else
+            {
+                T element = Minimum(RightOf(nodeToDelete));
+
+                child = RightOf(element);
+                parent = ParentOf(element);
+                color = ColorOf(element);
+
+                if (child != null)
+                {
+                    child.Parent = parent;
+                }
+
+                if (parent == null)
+                {
+                    Root = child;
+                }
+                else if (element == LeftOf(parent))
+                {
+                    parent.Left = child;
+                }
+                else
+                {
+                    parent.Right = child;
+                }
+
+                if (ParentOf(element) == old)
+                {
+                    parent = element;
+                }
+
+                element.Color = old.Color;
+                element.Left = old.Left;
+                element.Right = old.Right;
+                element.Parent = old.Parent;
+
+                if (ParentOf(old) == null)
+                {
+                    Root = element;
+                }
+                else if (old == LeftOf(ParentOf(old)))
+                {
+                    ParentOf(old).Left = element;
+                }
+                else
+                {
+                    ParentOf(old).Right = element;
+                }
+
+                LeftOf(old).Parent = element;
+
+                if (RightOf(old) != null)
+                {
+                    RightOf(old).Parent = element;
+                }
+
+                if (child != null && color == Black)
+                {
+                    RestoreBalanceAfterRemoval(child);
+                }
+
+                return old;
+            }
+
+            parent = ParentOf(nodeToDelete);
+            color = ColorOf(nodeToDelete);
+
+            if (child != null)
+            {
+                child.Parent = parent;
+            }
+
+            if (parent == null)
+            {
+                Root = child;
+            }
+            else if (nodeToDelete == LeftOf(parent))
+            {
+                parent.Left = child;
+            }
+            else
+            {
+                parent.Right = child;
+            }
+
+            if (child != null && color == Black)
+            {
+                RestoreBalanceAfterRemoval(child);
+            }
+
+            return old;
+        }
+
+        #endregion
+    }
+
+    public static class IntrusiveRedBlackTreeExtensions
+    {
+        /// <summary>
+        /// Retrieve the node that is considered equal to the key by the comparator.
+        /// </summary>
+        /// <param name="tree">Tree to search at</param>
+        /// <param name="key">Key of the node to be found</param>
+        /// <returns>Node that is equal to <paramref name="key"/></returns>
+        public static N GetNodeByKey<N, K>(this IntrusiveRedBlackTree<N> tree, K key)
+            where N : IntrusiveRedBlackTreeNode<N>, IComparable<N>, IComparable<K>
+            where K : struct
+        {
+            N node = tree.RootNode;
+            while (node != null)
+            {
+                int cmp = node.CompareTo(key);
+                if (cmp < 0)
+                {
+                    node = node.Right;
+                }
+                else if (cmp > 0)
+                {
+                    node = node.Left;
+                }
+                else
+                {
+                    return node;
+                }
+            }
+            return null;
+        }
+    }
+}
--- a/Ryujinx.Common/Collections/IntrusiveRedBlackTreeImpl.cs
+++ b/Ryujinx.Common/Collections/IntrusiveRedBlackTreeImpl.cs
@@ -0,0 +1,356 @@
+using System;
+
+namespace Ryujinx.Common.Collections
+{
+    /// <summary>
+    /// Tree that provides the ability for O(logN) lookups for keys that exist in the tree, and O(logN) lookups for keys immediately greater than or less than a specified key.
+    /// </summary>
+    /// <typeparam name="T">Derived node type</typeparam>
+    public class IntrusiveRedBlackTreeImpl<T> where T : IntrusiveRedBlackTreeNode<T>
+    {
+        protected const bool Black = true;
+        protected const bool Red = false;
+        protected T Root = null;
+
+        internal T RootNode => Root;
+
+        /// <summary>
+        /// Number of nodes on the tree.
+        /// </summary>
+        public int Count { get; protected set; }
+
+        /// <summary>
+        /// Removes all nodes on the tree.
+        /// </summary>
+        public void Clear()
+        {
+            Root = null;
+            Count = 0;
+        }
+
+        /// <summary>
+        /// Finds the node whose key is immediately greater than <paramref name="node"/>.
+        /// </summary>
+        /// <param name="node">Node to find the successor of</param>
+        /// <returns>Successor of <paramref name="node"/></returns>
+        internal static T SuccessorOf(T node)
+        {
+            if (node.Right != null)
+            {
+                return Minimum(node.Right);
+            }
+            T parent = node.Parent;
+            while (parent != null && node == parent.Right)
+            {
+                node = parent;
+                parent = parent.Parent;
+            }
+            return parent;
+        }
+
+        /// <summary>
+        /// Finds the node whose key is immediately less than <paramref name="node"/>.
+        /// </summary>
+        /// <param name="node">Node to find the predecessor of</param>
+        /// <returns>Predecessor of <paramref name="node"/></returns>
+        internal static T PredecessorOf(T node)
+        {
+            if (node.Left != null)
+            {
+                return Maximum(node.Left);
+            }
+            T parent = node.Parent;
+            while (parent != null && node == parent.Left)
+            {
+                node = parent;
+                parent = parent.Parent;
+            }
+            return parent;
+        }
+
+        /// <summary>
+        /// Returns the node with the largest key where <paramref name="node"/> is considered the root node.
+        /// </summary>
+        /// <param name="node">Root node</param>
+        /// <returns>Node with the maximum key in the tree of <paramref name="node"/></returns>
+        protected static T Maximum(T node)
+        {
+            T tmp = node;
+            while (tmp.Right != null)
+            {
+                tmp = tmp.Right;
+            }
+
+            return tmp;
+        }
+
+        /// <summary>
+        /// Returns the node with the smallest key where <paramref name="node"/> is considered the root node.
+        /// </summary>
+        /// <param name="node">Root node</param>
+        /// <returns>Node with the minimum key in the tree of <paramref name="node"/></returns>
+        /// <exception cref="ArgumentNullException"><paramref name="node"/> is null</exception>
+        protected static T Minimum(T node)
+        {
+            if (node == null)
+            {
+                throw new ArgumentNullException(nameof(node));
+            }
+            T tmp = node;
+            while (tmp.Left != null)
+            {
+                tmp = tmp.Left;
+            }
+
+            return tmp;
+        }
+
+        protected void RestoreBalanceAfterRemoval(T balanceNode)
+        {
+            T ptr = balanceNode;
+
+            while (ptr != Root && ColorOf(ptr) == Black)
+            {
+                if (ptr == LeftOf(ParentOf(ptr)))
+                {
+                    T sibling = RightOf(ParentOf(ptr));
+
+                    if (ColorOf(sibling) == Red)
+                    {
+                        SetColor(sibling, Black);
+                        SetColor(ParentOf(ptr), Red);
+                        RotateLeft(ParentOf(ptr));
+                        sibling = RightOf(ParentOf(ptr));
+                    }
+                    if (ColorOf(LeftOf(sibling)) == Black && ColorOf(RightOf(sibling)) == Black)
+                    {
+                        SetColor(sibling, Red);
+                        ptr = ParentOf(ptr);
+                    }
+                    else
+                    {
+                        if (ColorOf(RightOf(sibling)) == Black)
+                        {
+                            SetColor(LeftOf(sibling), Black);
+                            SetColor(sibling, Red);
+                            RotateRight(sibling);
+                            sibling = RightOf(ParentOf(ptr));
+                        }
+                        SetColor(sibling, ColorOf(ParentOf(ptr)));
+                        SetColor(ParentOf(ptr), Black);
+                        SetColor(RightOf(sibling), Black);
+                        RotateLeft(ParentOf(ptr));
+                        ptr = Root;
+                    }
+                }
+                else
+                {
+                    T sibling = LeftOf(ParentOf(ptr));
+
+                    if (ColorOf(sibling) == Red)
+                    {
+                        SetColor(sibling, Black);
+                        SetColor(ParentOf(ptr), Red);
+                        RotateRight(ParentOf(ptr));
+                        sibling = LeftOf(ParentOf(ptr));
+                    }
+                    if (ColorOf(RightOf(sibling)) == Black && ColorOf(LeftOf(sibling)) == Black)
+                    {
+                        SetColor(sibling, Red);
+                        ptr = ParentOf(ptr);
+                    }
+                    else
+                    {
+                        if (ColorOf(LeftOf(sibling)) == Black)
+                        {
+                            SetColor(RightOf(sibling), Black);
+                            SetColor(sibling, Red);
+                            RotateLeft(sibling);
+                            sibling = LeftOf(ParentOf(ptr));
+                        }
+                        SetColor(sibling, ColorOf(ParentOf(ptr)));
+                        SetColor(ParentOf(ptr), Black);
+                        SetColor(LeftOf(sibling), Black);
+                        RotateRight(ParentOf(ptr));
+                        ptr = Root;
+                    }
+                }
+            }
+            SetColor(ptr, Black);
+        }
+
+        protected void RestoreBalanceAfterInsertion(T balanceNode)
+        {
+            SetColor(balanceNode, Red);
+            while (balanceNode != null && balanceNode != Root && ColorOf(ParentOf(balanceNode)) == Red)
+            {
+                if (ParentOf(balanceNode) == LeftOf(ParentOf(ParentOf(balanceNode))))
+                {
+                    T sibling = RightOf(ParentOf(ParentOf(balanceNode)));
+
+                    if (ColorOf(sibling) == Red)
+                    {
+                        SetColor(ParentOf(balanceNode), Black);
+                        SetColor(sibling, Black);
+                        SetColor(ParentOf(ParentOf(balanceNode)), Red);
+                        balanceNode = ParentOf(ParentOf(balanceNode));
+                    }
+                    else
+                    {
+                        if (balanceNode == RightOf(ParentOf(balanceNode)))
+                        {
+                            balanceNode = ParentOf(balanceNode);
+                            RotateLeft(balanceNode);
+                        }
+                        SetColor(ParentOf(balanceNode), Black);
+                        SetColor(ParentOf(ParentOf(balanceNode)), Red);
+                        RotateRight(ParentOf(ParentOf(balanceNode)));
+                    }
+                }
+                else
+                {
+                    T sibling = LeftOf(ParentOf(ParentOf(balanceNode)));
+
+                    if (ColorOf(sibling) == Red)
+                    {
+                        SetColor(ParentOf(balanceNode), Black);
+                        SetColor(sibling, Black);
+                        SetColor(ParentOf(ParentOf(balanceNode)), Red);
+                        balanceNode = ParentOf(ParentOf(balanceNode));
+                    }
+                    else
+                    {
+                        if (balanceNode == LeftOf(ParentOf(balanceNode)))
+                        {
+                            balanceNode = ParentOf(balanceNode);
+                            RotateRight(balanceNode);
+                        }
+                        SetColor(ParentOf(balanceNode), Black);
+                        SetColor(ParentOf(ParentOf(balanceNode)), Red);
+                        RotateLeft(ParentOf(ParentOf(balanceNode)));
+                    }
+                }
+            }
+            SetColor(Root, Black);
+        }
+
+        protected virtual void RotateLeft(T node)
+        {
+            if (node != null)
+            {
+                T right = RightOf(node);
+                node.Right = LeftOf(right);
+                if (node.Right != null)
+                {
+                    node.Right.Parent = node;
+                }
+                T nodeParent = ParentOf(node);
+                right.Parent = nodeParent;
+                if (nodeParent == null)
+                {
+                    Root = right;
+                }
+                else if (node == LeftOf(nodeParent))
+                {
+                    nodeParent.Left = right;
+                }
+                else
+                {
+                    nodeParent.Right = right;
+                }
+                right.Left = node;
+                node.Parent = right;
+            }
+        }
+
+        protected virtual void RotateRight(T node)
+        {
+            if (node != null)
+            {
+                T left = LeftOf(node);
+                node.Left = RightOf(left);
+                if (node.Left != null)
+                {
+                    node.Left.Parent = node;
+                }
+                T nodeParent = ParentOf(node);
+                left.Parent = nodeParent;
+                if (nodeParent == null)
+                {
+                    Root = left;
+                }
+                else if (node == RightOf(nodeParent))
+                {
+                    nodeParent.Right = left;
+                }
+                else
+                {
+                    nodeParent.Left = left;
+                }
+                left.Right = node;
+                node.Parent = left;
+            }
+        }
+
+        #region Safety-Methods
+
+        // These methods save memory by allowing us to forego sentinel nil nodes, as well as serve as protection against NullReferenceExceptions.
+
+        /// <summary>
+        /// Returns the color of <paramref name="node"/>, or Black if it is null.
+        /// </summary>
+        /// <param name="node">Node</param>
+        /// <returns>The boolean color of <paramref name="node"/>, or black if null</returns>
+        protected static bool ColorOf(T node)
+        {
+            return node == null || node.Color;
+        }
+
+        /// <summary>
+        /// Sets the color of <paramref name="node"/> node to <paramref name="color"/>.
+        /// <br></br>
+        /// This method does nothing if <paramref name="node"/> is null.
+        /// </summary>
+        /// <param name="node">Node to set the color of</param>
+        /// <param name="color">Color (Boolean)</param>
+        protected static void SetColor(T node, bool color)
+        {
+            if (node != null)
+            {
+                node.Color = color;
+            }
+        }
+
+        /// <summary>
+        /// This method returns the left node of <paramref name="node"/>, or null if <paramref name="node"/> is null.
+        /// </summary>
+        /// <param name="node">Node to retrieve the left child from</param>
+        /// <returns>Left child of <paramref name="node"/></returns>
+        protected static T LeftOf(T node)
+        {
+            return node?.Left;
+        }
+
+        /// <summary>
+        /// This method returns the right node of <paramref name="node"/>, or null if <paramref name="node"/> is null.
+        /// </summary>
+        /// <param name="node">Node to retrieve the right child from</param>
+        /// <returns>Right child of <paramref name="node"/></returns>
+        protected static T RightOf(T node)
+        {
+            return node?.Right;
+        }
+
+        /// <summary>
+        /// Returns the parent node of <paramref name="node"/>, or null if <paramref name="node"/> is null.
+        /// </summary>
+        /// <param name="node">Node to retrieve the parent from</param>
+        /// <returns>Parent of <paramref name="node"/></returns>
+        protected static T ParentOf(T node)
+        {
+            return node?.Parent;
+        }
+
+        #endregion
+    }
+}
--- a/Ryujinx.Common/Collections/IntrusiveRedBlackTreeNode.cs
+++ b/Ryujinx.Common/Collections/IntrusiveRedBlackTreeNode.cs
@@ -0,0 +1,16 @@
+namespace Ryujinx.Common.Collections
+{
+    /// <summary>
+    /// Represents a node in the Red-Black Tree.
+    /// </summary>
+    public class IntrusiveRedBlackTreeNode<T> where T : IntrusiveRedBlackTreeNode<T>
+    {
+        public bool Color = true;
+        public T Left;
+        public T Right;
+        public T Parent;
+
+        public T Predecessor => IntrusiveRedBlackTreeImpl<T>.PredecessorOf((T)this);
+        public T Successor => IntrusiveRedBlackTreeImpl<T>.SuccessorOf((T)this);
+    }
+}
--- a/Ryujinx.Common/Collections/TreeDictionary.cs
+++ b/Ryujinx.Common/Collections/TreeDictionary.cs
@@ -10,14 +10,8 @@ namespace Ryujinx.Common.Collections
    /// </summary>
    /// <typeparam name="K">Key</typeparam>
    /// <typeparam name="V">Value</typeparam>
-    public class TreeDictionary<K, V> : IDictionary<K, V> where K : IComparable<K>
+    public class TreeDictionary<K, V> : IntrusiveRedBlackTreeImpl<Node<K, V>>, IDictionary<K, V> where K : IComparable<K>
    {
-        private const bool Black = true;
-        private const bool Red = false;
-        private Node<K, V> _root = null;
-        private int _count = 0;
-        public TreeDictionary() { }
-
        #region Public Methods

        /// <summary>
@@ -57,7 +51,7 @@ namespace Ryujinx.Common.Collections
            {
                throw new ArgumentNullException(nameof(key));
            }
-            if (null == value)
+            if (value == null)
            {
                throw new ArgumentNullException(nameof(value));
            }
@@ -78,7 +72,7 @@ namespace Ryujinx.Common.Collections
            }
            if (Delete(key) != null)
            {
-                _count--;
+                Count--;
            }
        }

@@ -160,13 +154,12 @@ namespace Ryujinx.Common.Collections

            Queue<Node<K, V>> nodes = new Queue<Node<K, V>>();

-            if (this._root != null)
+            if (this.Root != null)
            {
-                nodes.Enqueue(this._root);
+                nodes.Enqueue(this.Root);
            }
-            while (nodes.Count > 0)
+            while (nodes.TryDequeue(out Node<K, V> node))
            {
-                Node<K, V> node = nodes.Dequeue();
                list.Add(new KeyValuePair<K, V>(node.Key, node.Value));
                if (node.Left != null)
                {
@@ -188,7 +181,7 @@ namespace Ryujinx.Common.Collections
        {
            List<KeyValuePair<K, V>> list = new List<KeyValuePair<K, V>>();

-            AddToList(_root, list);
+            AddToList(Root, list);

            return list;
        }
@@ -229,7 +222,7 @@ namespace Ryujinx.Common.Collections
                throw new ArgumentNullException(nameof(key));
            }

-            Node<K, V> node = _root;
+            Node<K, V> node = Root;
            while (node != null)
            {
                int cmp = key.CompareTo(node.Key);
@@ -275,7 +268,7 @@ namespace Ryujinx.Common.Collections
        private Node<K, V> BSTInsert(K key, V value)
        {
            Node<K, V> parent = null;
-            Node<K, V> node = _root;
+            Node<K, V> node = Root;

            while (node != null)
            {
@@ -298,7 +291,7 @@ namespace Ryujinx.Common.Collections
            Node<K, V> newNode = new Node<K, V>(key, value, parent);
            if (newNode.Parent == null)
            {
-                _root = newNode;
+                Root = newNode;
            }
            else if (key.CompareTo(parent.Key) < 0)
            {
@@ -308,7 +301,7 @@ namespace Ryujinx.Common.Collections
            {
                parent.Right = newNode;
            }
-            _count++;
+            Count++;
            return newNode;
        }

@@ -344,9 +337,8 @@ namespace Ryujinx.Common.Collections

            if (ParentOf(replacementNode) == null)
            {
-                _root = tmp;
+                Root = tmp;
            }
-
            else if (replacementNode == LeftOf(ParentOf(replacementNode)))
            {
                ParentOf(replacementNode).Left = tmp;
@@ -370,43 +362,6 @@ namespace Ryujinx.Common.Collections
            return replacementNode;
        }

-        /// <summary>
-        /// Returns the node with the largest key where <paramref name="node"/> is considered the root node.
-        /// </summary>
-        /// <param name="node">Root Node</param>
-        /// <returns>Node with the maximum key in the tree of <paramref name="node"/></returns>
-        private static Node<K, V> Maximum(Node<K, V> node)
-        {
-            Node<K, V> tmp = node;
-            while (tmp.Right != null)
-            {
-                tmp = tmp.Right;
-            }
-
-            return tmp;
-        }
-
-        /// <summary>
-        /// Returns the node with the smallest key where <paramref name="node"/> is considered the root node.
-        /// </summary>
-        /// <param name="node">Root Node</param>
-        /// <returns>Node with the minimum key in the tree of <paramref name="node"/></returns>
-        ///<exception cref="ArgumentNullException"><paramref name="node"/> is null</exception>
-        private static Node<K, V> Minimum(Node<K, V> node)
-        {
-            if (node == null)
-            {
-                throw new ArgumentNullException(nameof(node));
-            }
-            Node<K, V> tmp = node;
-            while (tmp.Left != null)
-            {
-                tmp = tmp.Left;
-            }
-
-            return tmp;
-        }
-
        /// <summary>
        /// Returns the node whose key immediately less than or equal to <paramref name="key"/>.
        /// </summary>
@@ -419,7 +374,7 @@ namespace Ryujinx.Common.Collections
            {
                throw new ArgumentNullException(nameof(key));
            }
-            Node<K, V> tmp = _root;
+            Node<K, V> tmp = Root;

            while (tmp != null)
            {
@@ -473,7 +428,7 @@ namespace Ryujinx.Common.Collections
            {
                throw new ArgumentNullException(nameof(key));
            }
-            Node<K, V> tmp = _root;
+            Node<K, V> tmp = Root;

            while (tmp != null)
            {
@@ -515,294 +470,6 @@ namespace Ryujinx.Common.Collections
            return null;
        }

-        /// <summary>
-        /// Finds the node with the key is immediately greater than <paramref name="node"/>.
-        /// </summary>
-        /// <param name="node">Node to find the successor of</param>
-        /// <returns>Successor of <paramref name="node"/></returns>
-        private static Node<K, V> SuccessorOf(Node<K, V> node)
-        {
-            if (node.Right != null)
-            {
-                return Minimum(node.Right);
-            }
-            Node<K, V> parent = node.Parent;
-            while (parent != null && node == parent.Right)
-            {
-                node = parent;
-                parent = parent.Parent;
-            }
-            return parent;
-        }
-
-        /// <summary>
-        /// Finds the node whose key is immediately less than <paramref name="node"/>.
-        /// </summary>
-        /// <param name="node">Node to find the predecessor of</param>
-        /// <returns>Predecessor of <paramref name="node"/></returns>
-        private static Node<K, V> PredecessorOf(Node<K, V> node)
-        {
-            if (node.Left != null)
-            {
-                return Maximum(node.Left);
-            }
-            Node<K, V> parent = node.Parent;
-            while (parent != null && node == parent.Left)
-            {
-                node = parent;
-                parent = parent.Parent;
-            }
-            return parent;
-        }
-
-        #endregion
-
-        #region Private Methods (RBL)
-
-        private void RestoreBalanceAfterRemoval(Node<K, V> balanceNode)
-        {
-            Node<K, V> ptr = balanceNode;
-
-            while (ptr != _root && ColorOf(ptr) == Black)
-            {
-                if (ptr == LeftOf(ParentOf(ptr)))
-                {
-                    Node<K, V> sibling = RightOf(ParentOf(ptr));
-
-                    if (ColorOf(sibling) == Red)
-                    {
-                        SetColor(sibling, Black);
-                        SetColor(ParentOf(ptr), Red);
-                        RotateLeft(ParentOf(ptr));
-                        sibling = RightOf(ParentOf(ptr));
-                    }
-                    if (ColorOf(LeftOf(sibling)) == Black && ColorOf(RightOf(sibling)) == Black)
-                    {
-                        SetColor(sibling, Red);
-                        ptr = ParentOf(ptr);
-                    }
-                    else
-                    {
-                        if (ColorOf(RightOf(sibling)) == Black)
-                        {
-                            SetColor(LeftOf(sibling), Black);
-                            SetColor(sibling, Red);
-                            RotateRight(sibling);
-                            sibling = RightOf(ParentOf(ptr));
-                        }
-                        SetColor(sibling, ColorOf(ParentOf(ptr)));
-                        SetColor(ParentOf(ptr), Black);
-                        SetColor(RightOf(sibling), Black);
-                        RotateLeft(ParentOf(ptr));
-                        ptr = _root;
-                    }
-                }
-                else
-                {
-                    Node<K, V> sibling = LeftOf(ParentOf(ptr));
-
-                    if (ColorOf(sibling) == Red)
-                    {
-                        SetColor(sibling, Black);
-                        SetColor(ParentOf(ptr), Red);
-                        RotateRight(ParentOf(ptr));
-                        sibling = LeftOf(ParentOf(ptr));
-                    }
-                    if (ColorOf(RightOf(sibling)) == Black && ColorOf(LeftOf(sibling)) == Black)
-                    {
-                        SetColor(sibling, Red);
-                        ptr = ParentOf(ptr);
-                    }
-                    else
-                    {
-                        if (ColorOf(LeftOf(sibling)) == Black)
-                        {
-                            SetColor(RightOf(sibling), Black);
-                            SetColor(sibling, Red);
-                            RotateLeft(sibling);
-                            sibling = LeftOf(ParentOf(ptr));
-                        }
-                        SetColor(sibling, ColorOf(ParentOf(ptr)));
-                        SetColor(ParentOf(ptr), Black);
-                        SetColor(LeftOf(sibling), Black);
-                        RotateRight(ParentOf(ptr));
-                        ptr = _root;
-                    }
-                }
-            }
-            SetColor(ptr, Black);
-        }
-
-        private void RestoreBalanceAfterInsertion(Node<K, V> balanceNode)
-        {
-            SetColor(balanceNode, Red);
-            while (balanceNode != null && balanceNode != _root && ColorOf(ParentOf(balanceNode)) == Red)
-            {
-                if (ParentOf(balanceNode) == LeftOf(ParentOf(ParentOf(balanceNode))))
-                {
-                    Node<K, V> sibling = RightOf(ParentOf(ParentOf(balanceNode)));
-
-                    if (ColorOf(sibling) == Red)
-                    {
-                        SetColor(ParentOf(balanceNode), Black);
-                        SetColor(sibling, Black);
-                        SetColor(ParentOf(ParentOf(balanceNode)), Red);
-                        balanceNode = ParentOf(ParentOf(balanceNode));
-                    }
-                    else
-                    {
-                        if (balanceNode == RightOf(ParentOf(balanceNode)))
-                        {
-                            balanceNode = ParentOf(balanceNode);
-                            RotateLeft(balanceNode);
-                        }
-                        SetColor(ParentOf(balanceNode), Black);
-                        SetColor(ParentOf(ParentOf(balanceNode)), Red);
-                        RotateRight(ParentOf(ParentOf(balanceNode)));
-                    }
-                }
-                else
-                {
-                    Node<K, V> sibling = LeftOf(ParentOf(ParentOf(balanceNode)));
-
-                    if (ColorOf(sibling) == Red)
-                    {
-                        SetColor(ParentOf(balanceNode), Black);
-                        SetColor(sibling, Black);
-                        SetColor(ParentOf(ParentOf(balanceNode)), Red);
-                        balanceNode = ParentOf(ParentOf(balanceNode));
-                    }
-                    else
-                    {
-                        if (balanceNode == LeftOf(ParentOf(balanceNode)))
-                        {
-                            balanceNode = ParentOf(balanceNode);
-                            RotateRight(balanceNode);
-                        }
-                        SetColor(ParentOf(balanceNode), Black);
-                        SetColor(ParentOf(ParentOf(balanceNode)), Red);
-                        RotateLeft(ParentOf(ParentOf(balanceNode)));
-                    }
-                }
-            }
-            SetColor(_root, Black);
-        }
-
-        private void RotateLeft(Node<K, V> node)
-        {
-            if (node != null)
-            {
-                Node<K, V> right = RightOf(node);
-                node.Right = LeftOf(right);
-                if (LeftOf(right) != null)
-                {
-                    LeftOf(right).Parent = node;
-                }
-                right.Parent = ParentOf(node);
-                if (ParentOf(node) == null)
-                {
-                    _root = right;
-                }
-                else if (node == LeftOf(ParentOf(node)))
-                {
-                    ParentOf(node).Left = right;
-                }
-                else
-                {
-                    ParentOf(node).Right = right;
-                }
-                right.Left = node;
-                node.Parent = right;
-            }
-        }
-
-        private void RotateRight(Node<K, V> node)
-        {
-            if (node != null)
-            {
-                Node<K, V> left = LeftOf(node);
-                node.Left = RightOf(left);
-                if (RightOf(left) != null)
-                {
-                    RightOf(left).Parent = node;
-                }
-                left.Parent = node.Parent;
-                if (ParentOf(node) == null)
-                {
-                    _root = left;
-                }
-                else if (node == RightOf(ParentOf(node)))
-                {
-                    ParentOf(node).Right = left;
-                }
-                else
-                {
-                    ParentOf(node).Left = left;
-                }
-                left.Right = node;
-                node.Parent = left;
-            }
-        }
-        #endregion
-
-        #region Safety-Methods
-
-        // These methods save memory by allowing us to forego sentinel nil nodes, as well as serve as protection against NullReferenceExceptions.
-
-        /// <summary>
-        /// Returns the color of <paramref name="node"/>, or Black if it is null.
-        /// </summary>
-        /// <param name="node">Node</param>
-        /// <returns>The boolean color of <paramref name="node"/>, or black if null</returns>
-        private static bool ColorOf(Node<K, V> node)
-        {
-            return node == null || node.Color;
-        }
-
-        /// <summary>
-        /// Sets the color of <paramref name="node"/> node to <paramref name="color"/>.
-        /// <br></br>
-        /// This method does nothing if <paramref name="node"/> is null.
-        /// </summary>
-        /// <param name="node">Node to set the color of</param>
-        /// <param name="color">Color (Boolean)</param>
-        private static void SetColor(Node<K, V> node, bool color)
-        {
-            if (node != null)
-            {
-                node.Color = color;
-            }
-        }
-
-        /// <summary>
-        /// This method returns the left node of <paramref name="node"/>, or null if <paramref name="node"/> is null.
-        /// </summary>
-        /// <param name="node">Node to retrieve the left child from</param>
-        /// <returns>Left child of <paramref name="node"/></returns>
-        private static Node<K, V> LeftOf(Node<K, V> node)
-        {
-            return node?.Left;
-        }
-
-        /// <summary>
-        /// This method returns the right node of <paramref name="node"/>, or null if <paramref name="node"/> is null.
-        /// </summary>
-        /// <param name="node">Node to retrieve the right child from</param>
-        /// <returns>Right child of <paramref name="node"/></returns>
-        private static Node<K, V> RightOf(Node<K, V> node)
-        {
-            return node?.Right;
-        }
-
-        /// <summary>
-        /// Returns the parent node of <paramref name="node"/>, or null if <paramref name="node"/> is null.
-        /// </summary>
-        /// <param name="node">Node to retrieve the parent from</param>
-        /// <returns>Parent of <paramref name="node"/></returns>
-        private static Node<K, V> ParentOf(Node<K, V> node)
-        {
-            return node?.Parent;
-        }
        #endregion

        #region Interface Implementations
@@ -819,9 +486,9 @@ namespace Ryujinx.Common.Collections

        bool IDictionary<K, V>.Remove(K key)
        {
-            int count = _count;
+            int count = Count;
            Remove(key);
-            return count > _count;
+            return count > Count;
        }

        public bool TryGetValue(K key, [MaybeNullWhen(false)] out V value)
@@ -845,12 +512,6 @@ namespace Ryujinx.Common.Collections
            Add(item.Key, item.Value);
        }

-        public void Clear()
-        {
-            _root = null;
-            _count = 0;
-        }
-
        public bool Contains(KeyValuePair<K, V> item)
        {
            if (item.Key == null)
@@ -895,9 +556,9 @@ namespace Ryujinx.Common.Collections

            if (node.Value.Equals(item.Value))
            {
-                int count = _count;
+                int count = Count;
                Remove(item.Key);
-                return count > _count;
+                return count > Count;
            }

            return false;
@@ -913,8 +574,6 @@ namespace Ryujinx.Common.Collections
            return GetKeyValues().GetEnumerator();
        }

-        public int Count => _count;
-
        public ICollection<K> Keys => GetKeyValues().Keys;

        public ICollection<V> Values => GetKeyValues().Values;
@@ -928,6 +587,7 @@ namespace Ryujinx.Common.Collections
        }

        #endregion
+
        #region Private Interface Helper Methods

        /// <summary>
@@ -938,14 +598,13 @@ namespace Ryujinx.Common.Collections
        {
            SortedList<K, V> set = new SortedList<K, V>();
            Queue<Node<K, V>> queue = new Queue<Node<K, V>>();
-            if (_root != null)
+            if (Root != null)
            {
-                queue.Enqueue(_root);
+                queue.Enqueue(Root);
            }

-            while (queue.Count > 0)
+            while (queue.TryDequeue(out Node<K, V> node))
            {
-                Node<K, V> node = queue.Dequeue();
                set.Add(node.Key, node.Value);
                if (null != node.Left)
                {
@@ -959,6 +618,7 @@ namespace Ryujinx.Common.Collections

            return set;
        }
+
        #endregion
    }

@@ -967,16 +627,12 @@ namespace Ryujinx.Common.Collections
    /// </summary>
    /// <typeparam name="K">Key of the node</typeparam>
    /// <typeparam name="V">Value of the node</typeparam>
-    class Node<K, V>
+    public class Node<K, V> : IntrusiveRedBlackTreeNode<Node<K, V>> where K : IComparable<K>
    {
-        public bool Color = true;
-        public Node<K, V> Left = null;
-        public Node<K, V> Right = null;
-        public Node<K, V> Parent = null;
-        public K Key;
-        public V Value;
+        internal K Key;
+        internal V Value;

-        public Node(K key, V value, Node<K, V> parent)
+        internal Node(K key, V value, Node<K, V> parent)
        {
            Key = key;
            Value = value;
--- a/Ryujinx.Graphics.Gpu/Image/FormatTable.cs
+++ b/Ryujinx.Graphics.Gpu/Image/FormatTable.cs
@@ -8,195 +8,542 @@ namespace Ryujinx.Graphics.Gpu.Image
    /// </summary>
    static class FormatTable
    {
-        private static Dictionary<uint, FormatInfo> _textureFormats = new Dictionary<uint, FormatInfo>()
+        private enum TextureFormat : uint
        {
-            { 0x2491d, new FormatInfo(Format.R8Unorm,           1,  1,  1,  1) },
-            { 0x1249d, new FormatInfo(Format.R8Snorm,           1,  1,  1,  1) },
-            { 0x4921d, new FormatInfo(Format.R8Uint,            1,  1,  1,  1) },
-            { 0x36d9d, new FormatInfo(Format.R8Sint,            1,  1,  1,  1) },
-            { 0x7ff9b, new FormatInfo(Format.R16Float,          1,  1,  2,  1) },
-            { 0x2491b, new FormatInfo(Format.R16Unorm,          1,  1,  2,  1) },
-            { 0x1249b, new FormatInfo(Format.R16Snorm,          1,  1,  2,  1) },
-            { 0x4921b, new FormatInfo(Format.R16Uint,           1,  1,  2,  1) },
-            { 0x36d9b, new FormatInfo(Format.R16Sint,           1,  1,  2,  1) },
-            { 0x7ff8f, new FormatInfo(Format.R32Float,          1,  1,  4,  1) },
-            { 0x4920f, new FormatInfo(Format.R32Uint,           1,  1,  4,  1) },
-            { 0x36d8f, new FormatInfo(Format.R32Sint,           1,  1,  4,  1) },
-            { 0x24918, new FormatInfo(Format.R8G8Unorm,         1,  1,  2,  2) },
-            { 0x12498, new FormatInfo(Format.R8G8Snorm,         1,  1,  2,  2) },
-            { 0x49218, new FormatInfo(Format.R8G8Uint,          1,  1,  2,  2) },
-            { 0x36d98, new FormatInfo(Format.R8G8Sint,          1,  1,  2,  2) },
-            { 0x7ff8c, new FormatInfo(Format.R16G16Float,       1,  1,  4,  2) },
-            { 0x2490c, new FormatInfo(Format.R16G16Unorm,       1,  1,  4,  2) },
-            { 0x1248c, new FormatInfo(Format.R16G16Snorm,       1,  1,  4,  2) },
-            { 0x4920c, new FormatInfo(Format.R16G16Uint,        1,  1,  4,  2) },
-            { 0x36d8c, new FormatInfo(Format.R16G16Sint,        1,  1,  4,  2) },
-            { 0x7ff84, new FormatInfo(Format.R32G32Float,       1,  1,  8,  2) },
-            { 0x49204, new FormatInfo(Format.R32G32Uint,        1,  1,  8,  2) },
-            { 0x36d84, new FormatInfo(Format.R32G32Sint,        1,  1,  8,  2) },
-            { 0x7ff82, new FormatInfo(Format.R32G32B32Float,    1,  1,  12, 3) },
-            { 0x49202, new FormatInfo(Format.R32G32B32Uint,     1,  1,  12, 3) },
-            { 0x36d82, new FormatInfo(Format.R32G32B32Sint,     1,  1,  12, 3) },
-            { 0x24908, new FormatInfo(Format.R8G8B8A8Unorm,     1,  1,  4,  4) },
-            { 0x12488, new FormatInfo(Format.R8G8B8A8Snorm,     1,  1,  4,  4) },
-            { 0x49208, new FormatInfo(Format.R8G8B8A8Uint,      1,  1,  4,  4) },
-            { 0x36d88, new FormatInfo(Format.R8G8B8A8Sint,      1,  1,  4,  4) },
-            { 0x7ff83, new FormatInfo(Format.R16G16B16A16Float, 1,  1,  8,  4) },
-            { 0x24903, new FormatInfo(Format.R16G16B16A16Unorm, 1,  1,  8,  4) },
-            { 0x12483, new FormatInfo(Format.R16G16B16A16Snorm, 1,  1,  8,  4) },
-            { 0x49203, new FormatInfo(Format.R16G16B16A16Uint,  1,  1,  8,  4) },
-            { 0x36d83, new FormatInfo(Format.R16G16B16A16Sint,  1,  1,  8,  4) },
-            { 0x7ff81, new FormatInfo(Format.R32G32B32A32Float, 1,  1,  16, 4) },
-            { 0x49201, new FormatInfo(Format.R32G32B32A32Uint,  1,  1,  16, 4) },
-            { 0x36d81, new FormatInfo(Format.R32G32B32A32Sint,  1,  1,  16, 4) },
-            { 0x2493a, new FormatInfo(Format.D16Unorm,          1,  1,  2,  1) },
-            { 0x493af, new FormatInfo(Format.D32Float,          1,  1,  4,  1) },
-            { 0x7ffaf, new FormatInfo(Format.D32Float,          1,  1,  4,  1) },
-            { 0x24a0e, new FormatInfo(Format.D24UnormS8Uint,    1,  1,  4,  2) },
-            { 0x24a29, new FormatInfo(Format.D24UnormS8Uint,    1,  1,  4,  2) },
-            { 0x48a29, new FormatInfo(Format.D24UnormS8Uint,    1,  1,  4,  2) },
-            { 0x4912b, new FormatInfo(Format.S8UintD24Unorm,    1,  1,  4,  2) },
-            { 0x25385, new FormatInfo(Format.D32FloatS8Uint,    1,  1,  8,  2) },
-            { 0x253b0, new FormatInfo(Format.D32FloatS8Uint,    1,  1,  8,  2) },
-            { 0xa4908, new FormatInfo(Format.R8G8B8A8Srgb,      1,  1,  4,  4) },
-            { 0x2491e, new FormatInfo(Format.R4G4Unorm,         1,  1,  1,  2) },
-            { 0x24912, new FormatInfo(Format.R4G4B4A4Unorm,     1,  1,  2,  4) },
-            { 0x24914, new FormatInfo(Format.R5G5B5A1Unorm,     1,  1,  2,  4) },
-            { 0x24915, new FormatInfo(Format.R5G6B5Unorm,       1,  1,  2,  3) },
-            { 0x24909, new FormatInfo(Format.R10G10B10A2Unorm,  1,  1,  4,  4) },
-            { 0x49209, new FormatInfo(Format.R10G10B10A2Uint,   1,  1,  4,  4) },
-            { 0x7ffa1, new FormatInfo(Format.R11G11B10Float,    1,  1,  4,  3) },
-            { 0x7ffa0, new FormatInfo(Format.R9G9B9E5Float,     1,  1,  4,  4) },
-            { 0x24924, new FormatInfo(Format.Bc1RgbaUnorm,      4,  4,  8,  4) },
-            { 0x24925, new FormatInfo(Format.Bc2Unorm,          4,  4,  16, 4) },
-            { 0x24926, new FormatInfo(Format.Bc3Unorm,          4,  4,  16, 4) },
-            { 0xa4924, new FormatInfo(Format.Bc1RgbaSrgb,       4,  4,  8,  4) },
-            { 0xa4925, new FormatInfo(Format.Bc2Srgb,           4,  4,  16, 4) },
-            { 0xa4926, new FormatInfo(Format.Bc3Srgb,           4,  4,  16, 4) },
-            { 0x24927, new FormatInfo(Format.Bc4Unorm,          4,  4,  8,  1) },
-            { 0x124a7, new FormatInfo(Format.Bc4Snorm,          4,  4,  8,  1) },
-            { 0x24928, new FormatInfo(Format.Bc5Unorm,          4,  4,  16, 2) },
-            { 0x124a8, new FormatInfo(Format.Bc5Snorm,          4,  4,  16, 2) },
-            { 0x24917, new FormatInfo(Format.Bc7Unorm,          4,  4,  16, 4) },
-            { 0xa4917, new FormatInfo(Format.Bc7Srgb,           4,  4,  16, 4) },
-            { 0x7ff90, new FormatInfo(Format.Bc6HSfloat,        4,  4,  16, 4) },
-            { 0x7ff91, new FormatInfo(Format.Bc6HUfloat,        4,  4,  16, 4) },
-            { 0x24906, new FormatInfo(Format.Etc2RgbUnorm,      4,  4,  8,  3) },
-            { 0x2490b, new FormatInfo(Format.Etc2RgbaUnorm,     4,  4,  16, 4) },
-            { 0xa4906, new FormatInfo(Format.Etc2RgbSrgb,       4,  4,  8,  3) },
-            { 0xa490b, new FormatInfo(Format.Etc2RgbaSrgb,      4,  4,  16, 4) },
-            { 0x24940, new FormatInfo(Format.Astc4x4Unorm,      4,  4,  16, 4) },
-            { 0x24950, new FormatInfo(Format.Astc5x4Unorm,      5,  4,  16, 4) },
-            { 0x24941, new FormatInfo(Format.Astc5x5Unorm,      5,  5,  16, 4) },
-            { 0x24951, new FormatInfo(Format.Astc6x5Unorm,      6,  5,  16, 4) },
-            { 0x24942, new FormatInfo(Format.Astc6x6Unorm,      6,  6,  16, 4) },
-            { 0x24955, new FormatInfo(Format.Astc8x5Unorm,      8,  5,  16, 4) },
-            { 0x24952, new FormatInfo(Format.Astc8x6Unorm,      8,  6,  16, 4) },
-            { 0x24944, new FormatInfo(Format.Astc8x8Unorm,      8,  8,  16, 4) },
-            { 0x24956, new FormatInfo(Format.Astc10x5Unorm,     10, 5,  16, 4) },
-            { 0x24957, new FormatInfo(Format.Astc10x6Unorm,     10, 6,  16, 4) },
-            { 0x24953, new FormatInfo(Format.Astc10x8Unorm,     10, 8,  16, 4) },
-            { 0x24945, new FormatInfo(Format.Astc10x10Unorm,    10, 10, 16, 4) },
-            { 0x24954, new FormatInfo(Format.Astc12x10Unorm,    12, 10, 16, 4) },
-            { 0x24946, new FormatInfo(Format.Astc12x12Unorm,    12, 12, 16, 4) },
-            { 0xa4940, new FormatInfo(Format.Astc4x4Srgb,       4,  4,  16, 4) },
-            { 0xa4950, new FormatInfo(Format.Astc5x4Srgb,       5,  4,  16, 4) },
-            { 0xa4941, new FormatInfo(Format.Astc5x5Srgb,       5,  5,  16, 4) },
-            { 0xa4951, new FormatInfo(Format.Astc6x5Srgb,       6,  5,  16, 4) },
-            { 0xa4942, new FormatInfo(Format.Astc6x6Srgb,       6,  6,  16, 4) },
-            { 0xa4955, new FormatInfo(Format.Astc8x5Srgb,       8,  5,  16, 4) },
-            { 0xa4952, new FormatInfo(Format.Astc8x6Srgb,       8,  6,  16, 4) },
-            { 0xa4944, new FormatInfo(Format.Astc8x8Srgb,       8,  8,  16, 4) },
-            { 0xa4956, new FormatInfo(Format.Astc10x5Srgb,      10, 5,  16, 4) },
-            { 0xa4957, new FormatInfo(Format.Astc10x6Srgb,      10, 6,  16, 4) },
-            { 0xa4953, new FormatInfo(Format.Astc10x8Srgb,      10, 8,  16, 4) },
-            { 0xa4945, new FormatInfo(Format.Astc10x10Srgb,     10, 10, 16, 4) },
-            { 0xa4954, new FormatInfo(Format.Astc12x10Srgb,     12, 10, 16, 4) },
-            { 0xa4946, new FormatInfo(Format.Astc12x12Srgb,     12, 12, 16, 4) },
-            { 0x24913, new FormatInfo(Format.A1B5G5R5Unorm,     1,  1,  2,  4) }
+            // Formats
+            R32G32B32A32 = 0x01,
+            R32G32B32 = 0x02,
+            R16G16B16A16 = 0x03,
+            R32G32 = 0x04,
+            R32B24G8 = 0x05,
+            X8B8G8R8 = 0x07,
+            A8B8G8R8 = 0x08,
+            A2B10G10R10 = 0x09,
+            R16G16 = 0x0c,
+            G8R24 = 0x0d,
+            G24R8 = 0x0e,
+            R32 = 0x0f,
+            A4B4G4R4 = 0x12,
+            A5B5G5R1 = 0x13,
+            A1B5G5R5 = 0x14,
+            B5G6R5 = 0x15,
+            B6G5R5 = 0x16,
+            G8R8 = 0x18,
+            R16 = 0x1b,
+            Y8Video = 0x1c,
+            R8 = 0x1d,
+            G4R4 = 0x1e,
+            R1 = 0x1f,
+            E5B9G9R9SharedExp = 0x20,
+            Bf10Gf11Rf11 = 0x21,
+            G8B8G8R8 = 0x22,
+            B8G8R8G8 = 0x23,
+            Bc1 = 0x24,
+            Bc2 = 0x25,
+            Bc3 = 0x26,
+            Bc4 = 0x27,
+            Bc5 = 0x28,
+            Bc6HSf16 = 0x10,
+            Bc6HUf16 = 0x11,
+            Bc7U = 0x17,
+            Etc2Rgb = 0x06,
+            Etc2RgbPta = 0x0a,
+            Etc2Rgba = 0x0b,
+            Eac = 0x19,
+            Eacx2 = 0x1a,
+            Z24S8 = 0x29,
+            X8Z24 = 0x2a,
+            S8Z24 = 0x2b,
+            X4V4Z24Cov4R4V = 0x2c,
+            X4V4Z24Cov8R8V = 0x2d,
+            V8Z24Cov4R12V = 0x2e,
+            Zf32 = 0x2f,
+            Zf32X24S8 = 0x30,
+            X8Z24X20V4S8Cov4R4V = 0x31,
+            X8Z24X20V4S8Cov8R8V = 0x32,
+            Zf32X20V4X8Cov4R4V = 0x33,
+            Zf32X20V4X8Cov8R8V = 0x34,
+            Zf32X20V4S8Cov4R4V = 0x35,
+            Zf32X20V4S8Cov8R8V = 0x36,
+            X8Z24X16V8S8Cov4R12V = 0x37,
+            Zf32X16V8X8Cov4R12V = 0x38,
+            Zf32X16V8S8Cov4R12V = 0x39,
+            Z16 = 0x3a,
+            V8Z24Cov8R24V = 0x3b,
+            X8Z24X16V8S8Cov8R24V = 0x3c,
+            Zf32X16V8X8Cov8R24V = 0x3d,
+            Zf32X16V8S8Cov8R24V = 0x3e,
+            Astc2D4x4 = 0x40,
+            Astc2D5x4 = 0x50,
+            Astc2D5x5 = 0x41,
+            Astc2D6x5 = 0x51,
+            Astc2D6x6 = 0x42,
+            Astc2D8x5 = 0x55,
+            Astc2D8x6 = 0x52,
+            Astc2D8x8 = 0x44,
+            Astc2D10x5 = 0x56,
+            Astc2D10x6 = 0x57,
+            Astc2D10x8 = 0x53,
+            Astc2D10x10 = 0x45,
+            Astc2D12x10 = 0x54,
+            Astc2D12x12 = 0x46,
+
+            // Types
+            Snorm = 0x1,
+            Unorm = 0x2,
+            Sint = 0x3,
+            Uint = 0x4,
+            SnormForceFp16 = 0x5,
+            UnormForceFp16 = 0x6,
+            Float = 0x7,
+
+            // Component Types
+            RSnorm = Snorm << 7,
+            GSnorm = Snorm << 10,
+            BSnorm = Snorm << 13,
+            ASnorm = Snorm << 16,
+
+            RUnorm = Unorm << 7,
+            GUnorm = Unorm << 10,
+            BUnorm = Unorm << 13,
+            AUnorm = Unorm << 16,
+
+            RSint = Sint << 7,
+            GSint = Sint << 10,
+            BSint = Sint << 13,
+            ASint = Sint << 16,
+
+            RUint = Uint << 7,
+            GUint = Uint << 10,
+            BUint = Uint << 13,
+            AUint = Uint << 16,
+
+            RSnormForceFp16 = SnormForceFp16 << 7,
+            GSnormForceFp16 = SnormForceFp16 << 10,
+            BSnormForceFp16 = SnormForceFp16 << 13,
+            ASnormForceFp16 = SnormForceFp16 << 16,
+
+            RUnormForceFp16 = UnormForceFp16 << 7,
+            GUnormForceFp16 = UnormForceFp16 << 10,
+            BUnormForceFp16 = UnormForceFp16 << 13,
+            AUnormForceFp16 = UnormForceFp16 << 16,
+
+            RFloat = Float << 7,
+            GFloat = Float << 10,
+            BFloat = Float << 13,
+            AFloat = Float << 16,
+
+            Srgb = 0x1 << 19, // Custom encoding
+
+            // Combinations
+            R8Unorm                          = R8                | RUnorm | GUnorm | BUnorm | AUnorm,        // 0x2491d
+            R8Snorm                          = R8                | RSnorm | GSnorm | BSnorm | ASnorm,        // 0x1249d
+            R8Uint                           = R8                | RUint  | GUint  | BUint  | AUint,         // 0x4921d
+            R8Sint                           = R8                | RSint  | GSint  | BSint  | ASint,         // 0x36d9d
+            R16Float                         = R16               | RFloat | GFloat | BFloat | AFloat,        // 0x7ff9b
+            R16Unorm                         = R16               | RUnorm | GUnorm | BUnorm | AUnorm,        // 0x2491b
+            R16Snorm                         = R16               | RSnorm | GSnorm | BSnorm | ASnorm,        // 0x1249b
+            R16Uint                          = R16               | RUint  | GUint  | BUint  | AUint,         // 0x4921b
+            R16Sint                          = R16               | RSint  | GSint  | BSint  | ASint,         // 0x36d9b
+            R32Float                         = R32               | RFloat | GFloat | BFloat | AFloat,        // 0x7ff8f
+            R32Uint                          = R32               | RUint  | GUint  | BUint  | AUint,         // 0x4920f
+            R32Sint                          = R32               | RSint  | GSint  | BSint  | ASint,         // 0x36d8f
+            G8R8Unorm                        = G8R8              | RUnorm | GUnorm | BUnorm | AUnorm,        // 0x24918
+            G8R8Snorm                        = G8R8              | RSnorm | GSnorm | BSnorm | ASnorm,        // 0x12498
+            G8R8Uint                         = G8R8              | RUint  | GUint  | BUint  | AUint,         // 0x49218
+            G8R8Sint                         = G8R8              | RSint  | GSint  | BSint  | ASint,         // 0x36d98
+            R16G16Float                      = R16G16            | RFloat | GFloat | BFloat | AFloat,        // 0x7ff8c
+            R16G16Unorm                      = R16G16            | RUnorm | GUnorm | BUnorm | AUnorm,        // 0x2490c
+            R16G16Snorm                      = R16G16            | RSnorm | GSnorm | BSnorm | ASnorm,        // 0x1248c
+            R16G16Uint                       = R16G16            | RUint  | GUint  | BUint  | AUint,         // 0x4920c
+            R16G16Sint                       = R16G16            | RSint  | GSint  | BSint  | ASint,         // 0x36d8c
+            R32G32Float                      = R32G32            | RFloat | GFloat | BFloat | AFloat,        // 0x7ff84
+            R32G32Uint                       = R32G32            | RUint  | GUint  | BUint  | AUint,         // 0x49204
+            R32G32Sint                       = R32G32            | RSint  | GSint  | BSint  | ASint,         // 0x36d84
+            R32G32B32Float                   = R32G32B32         | RFloat | GFloat | BFloat | AFloat,        // 0x7ff82
+            R32G32B32Uint                    = R32G32B32         | RUint  | GUint  | BUint  | AUint,         // 0x49202
+            R32G32B32Sint                    = R32G32B32         | RSint  | GSint  | BSint  | ASint,         // 0x36d82
+            A8B8G8R8Unorm                    = A8B8G8R8          | RUnorm | GUnorm | BUnorm | AUnorm,        // 0x24908
+            A8B8G8R8Snorm                    = A8B8G8R8          | RSnorm | GSnorm | BSnorm | ASnorm,        // 0x12488
+            A8B8G8R8Uint                     = A8B8G8R8          | RUint  | GUint  | BUint  | AUint,         // 0x49208
+            A8B8G8R8Sint                     = A8B8G8R8          | RSint  | GSint  | BSint  | ASint,         // 0x36d88
+            R16G16B16A16Float                = R16G16B16A16      | RFloat | GFloat | BFloat | AFloat,        // 0x7ff83
+            R16G16B16A16Unorm                = R16G16B16A16      | RUnorm | GUnorm | BUnorm | AUnorm,        // 0x24903
+            R16G16B16A16Snorm                = R16G16B16A16      | RSnorm | GSnorm | BSnorm | ASnorm,        // 0x12483
+            R16G16B16A16Uint                 = R16G16B16A16      | RUint  | GUint  | BUint  | AUint,         // 0x49203
+            R16G16B16A16Sint                 = R16G16B16A16      | RSint  | GSint  | BSint  | ASint,         // 0x36d83
+            R32G32B32A32Float                = R32G32B32A32      | RFloat | GFloat | BFloat | AFloat,        // 0x7ff81
+            R32G32B32A32Uint                 = R32G32B32A32      | RUint  | GUint  | BUint  | AUint,         // 0x49201
+            R32G32B32A32Sint                 = R32G32B32A32      | RSint  | GSint  | BSint  | ASint,         // 0x36d81
+            Z16Unorm                         = Z16               | RUnorm | GUnorm | BUnorm | AUnorm,        // 0x2493a
+            Zf32RFloatGUintBUintAUint        = Zf32              | RFloat | GUint  | BUint  | AUint,         // 0x493af
+            Zf32Float                        = Zf32              | RFloat | GFloat | BFloat | AFloat,        // 0x7ffaf
+            G24R8RUintGUnormBUnormAUnorm     = G24R8             | RUint  | GUnorm | BUnorm | AUnorm,        // 0x24a0e
+            Z24S8RUintGUnormBUnormAUnorm     = Z24S8             | RUint  | GUnorm | BUnorm | AUnorm,        // 0x24a29
+            Z24S8RUintGUnormBUintAUint       = Z24S8             | RUint  | GUnorm | BUint  | AUint,         // 0x48a29
+            S8Z24RUnormGUintBUintAUint       = S8Z24             | RUnorm | GUint  | BUint  | AUint,         // 0x4912b
+            R32B24G8RFloatGUintBUnormAUnorm  = R32B24G8          | RFloat | GUint  | BUnorm | AUnorm,        // 0x25385
+            Zf32X24S8RFloatGUintBUnormAUnorm = Zf32X24S8         | RFloat | GUint  | BUnorm | AUnorm,        // 0x253b0
+            A8B8G8R8UnormSrgb                = A8B8G8R8          | RUnorm | GUnorm | BUnorm | AUnorm | Srgb, // 0xa4908
+            G4R4Unorm                        = G4R4              | RUnorm | GUnorm | BUnorm | AUnorm,        // 0x2491e
+            A4B4G4R4Unorm                    = A4B4G4R4          | RUnorm | GUnorm | BUnorm | AUnorm,        // 0x24912
+            A1B5G5R5Unorm                    = A1B5G5R5          | RUnorm | GUnorm | BUnorm | AUnorm,        // 0x24914
+            B5G6R5Unorm                      = B5G6R5            | RUnorm | GUnorm | BUnorm | AUnorm,        // 0x24915
+            A2B10G10R10Unorm                 = A2B10G10R10       | RUnorm | GUnorm | BUnorm | AUnorm,        // 0x24909
+            A2B10G10R10Uint                  = A2B10G10R10       | RUint  | GUint  | BUint  | AUint,         // 0x49209
+            Bf10Gf11Rf11Float                = Bf10Gf11Rf11      | RFloat | GFloat | BFloat | AFloat,        // 0x7ffa1
+            E5B9G9R9SharedExpFloat           = E5B9G9R9SharedExp | RFloat | GFloat | BFloat | AFloat,        // 0x7ffa0
+            Bc1Unorm                         = Bc1               | RUnorm | GUnorm | BUnorm | AUnorm,        // 0x24924
+            Bc2Unorm                         = Bc2               | RUnorm | GUnorm | BUnorm | AUnorm,        // 0x24925
+            Bc3Unorm                         = Bc3               | RUnorm | GUnorm | BUnorm | AUnorm,        // 0x24926
+            Bc1UnormSrgb                     = Bc1               | RUnorm | GUnorm | BUnorm | AUnorm | Srgb, // 0xa4924
+            Bc2UnormSrgb                     = Bc2               | RUnorm | GUnorm | BUnorm | AUnorm | Srgb, // 0xa4925
+            Bc3UnormSrgb                     = Bc3               | RUnorm | GUnorm | BUnorm | AUnorm | Srgb, // 0xa4926
+            Bc4Unorm                         = Bc4               | RUnorm | GUnorm | BUnorm | AUnorm,        // 0x24927
+            Bc4Snorm                         = Bc4               | RSnorm | GSnorm | BSnorm | ASnorm,        // 0x124a7
+            Bc5Unorm                         = Bc5               | RUnorm | GUnorm | BUnorm | AUnorm,        // 0x24928
+            Bc5Snorm                         = Bc5               | RSnorm | GSnorm | BSnorm | ASnorm,        // 0x124a8
+            Bc7UUnorm                        = Bc7U              | RUnorm | GUnorm | BUnorm | AUnorm,        // 0x24917
+            Bc7UUnormSrgb                    = Bc7U              | RUnorm | GUnorm | BUnorm | AUnorm | Srgb, // 0xa4917
+            Bc6HSf16Float                    = Bc6HSf16          | RFloat | GFloat | BFloat | AFloat,        // 0x7ff90
+            Bc6HUf16Float                    = Bc6HUf16          | RFloat | GFloat | BFloat | AFloat,        // 0x7ff91
+            Etc2RgbUnorm                     = Etc2Rgb           | RUnorm | GUnorm | BUnorm | AUnorm,        // 0x24906
+            Etc2RgbaUnorm                    = Etc2Rgba          | RUnorm | GUnorm | BUnorm | AUnorm,        // 0x2490b
+            Etc2RgbUnormSrgb                 = Etc2Rgb           | RUnorm | GUnorm | BUnorm | AUnorm | Srgb, // 0xa4906
+            Etc2RgbaUnormSrgb                = Etc2Rgba          | RUnorm | GUnorm | BUnorm | AUnorm | Srgb, // 0xa490b
+            Astc2D4x4Unorm                   = Astc2D4x4         | RUnorm | GUnorm | BUnorm | AUnorm,        // 0x24940
+            Astc2D5x4Unorm                   = Astc2D5x4         | RUnorm | GUnorm | BUnorm | AUnorm,        // 0x24950
+            Astc2D5x5Unorm                   = Astc2D5x5         | RUnorm | GUnorm | BUnorm | AUnorm,        // 0x24941
+            Astc2D6x5Unorm                   = Astc2D6x5         | RUnorm | GUnorm | BUnorm | AUnorm,        // 0x24951
+            Astc2D6x6Unorm                   = Astc2D6x6         | RUnorm | GUnorm | BUnorm | AUnorm,        // 0x24942
+            Astc2D8x5Unorm                   = Astc2D8x5         | RUnorm | GUnorm | BUnorm | AUnorm,        // 0x24955
+            Astc2D8x6Unorm                   = Astc2D8x6         | RUnorm | GUnorm | BUnorm | AUnorm,        // 0x24952
+            Astc2D8x8Unorm                   = Astc2D8x8         | RUnorm | GUnorm | BUnorm | AUnorm,        // 0x24944
+            Astc2D10x5Unorm                  = Astc2D10x5        | RUnorm | GUnorm | BUnorm | AUnorm,        // 0x24956
+            Astc2D10x6Unorm                  = Astc2D10x6        | RUnorm | GUnorm | BUnorm | AUnorm,        // 0x24957
+            Astc2D10x8Unorm                  = Astc2D10x8        | RUnorm | GUnorm | BUnorm | AUnorm,        // 0x24953
+            Astc2D10x10Unorm                 = Astc2D10x10       | RUnorm | GUnorm | BUnorm | AUnorm,        // 0x24945
+            Astc2D12x10Unorm                 = Astc2D12x10       | RUnorm | GUnorm | BUnorm | AUnorm,        // 0x24954
+            Astc2D12x12Unorm                 = Astc2D12x12       | RUnorm | GUnorm | BUnorm | AUnorm,        // 0x24946
+            Astc2D4x4UnormSrgb               = Astc2D4x4         | RUnorm | GUnorm | BUnorm | AUnorm | Srgb, // 0xa4940
+            Astc2D5x4UnormSrgb               = Astc2D5x4         | RUnorm | GUnorm | BUnorm | AUnorm | Srgb, // 0xa4950
+            Astc2D5x5UnormSrgb               = Astc2D5x5         | RUnorm | GUnorm | BUnorm | AUnorm | Srgb, // 0xa4941
+            Astc2D6x5UnormSrgb               = Astc2D6x5         | RUnorm | GUnorm | BUnorm | AUnorm | Srgb, // 0xa4951
+            Astc2D6x6UnormSrgb               = Astc2D6x6         | RUnorm | GUnorm | BUnorm | AUnorm | Srgb, // 0xa4942
+            Astc2D8x5UnormSrgb               = Astc2D8x5         | RUnorm | GUnorm | BUnorm | AUnorm | Srgb, // 0xa4955
+            Astc2D8x6UnormSrgb               = Astc2D8x6         | RUnorm | GUnorm | BUnorm | AUnorm | Srgb, // 0xa4952
+            Astc2D8x8UnormSrgb               = Astc2D8x8         | RUnorm | GUnorm | BUnorm | AUnorm | Srgb, // 0xa4944
+            Astc2D10x5UnormSrgb              = Astc2D10x5        | RUnorm | GUnorm | BUnorm | AUnorm | Srgb, // 0xa4956
+            Astc2D10x6UnormSrgb              = Astc2D10x6        | RUnorm | GUnorm | BUnorm | AUnorm | Srgb, // 0xa4957
+            Astc2D10x8UnormSrgb              = Astc2D10x8        | RUnorm | GUnorm | BUnorm | AUnorm | Srgb, // 0xa4953
+            Astc2D10x10UnormSrgb             = Astc2D10x10       | RUnorm | GUnorm | BUnorm | AUnorm | Srgb, // 0xa4945
+            Astc2D12x10UnormSrgb             = Astc2D12x10       | RUnorm | GUnorm | BUnorm | AUnorm | Srgb, // 0xa4954
+            Astc2D12x12UnormSrgb             = Astc2D12x12       | RUnorm | GUnorm | BUnorm | AUnorm | Srgb, // 0xa4946
+            A5B5G5R1Unorm                    = A5B5G5R1          | RUnorm | GUnorm | BUnorm | AUnorm,        // 0x24913
+        }
+
+        private enum VertexAttributeFormat : uint
+        {
+            // Width
+            R32G32B32A32 = 0x01,
+            R32G32B32 = 0x02,
+            R16G16B16A16 = 0x03,
+            R32G32 = 0x04,
+            R16G16B16 = 0x05,
+            A8B8G8R8 = 0x2f,
+            R8G8B8A8 = 0x0a,
+            X8B8G8R8 = 0x33,
+            A2B10G10R10 = 0x30,
+            B10G11R11 = 0x31,
+            R16G16 = 0x0f,
+            R32 = 0x12,
+            R8G8B8 = 0x13,
+            G8R8 = 0x32,
+            R8G8 = 0x18,
+            R16 = 0x1b,
+            R8 = 0x1d,
+            A8 = 0x34,
+
+            // Type
+            Snorm = 0x01,
+            Unorm = 0x02,
+            Sint = 0x03,
+            Uint = 0x04,
+            Uscaled = 0x05,
+            Sscaled = 0x06,
+            Float = 0x07,
+
+            // Combinations
+            R8Unorm             = (R8 << 21)           | (Unorm << 27),   // 0x13a00000
+            R8Snorm             = (R8 << 21)           | (Snorm << 27),   // 0x0ba00000
+            R8Uint              = (R8 << 21)           | (Uint << 27),    // 0x23a00000
+            R8Sint              = (R8 << 21)           | (Sint << 27),    // 0x1ba00000
+            R16Float            = (R16 << 21)          | (Float << 27),   // 0x3b600000
+            R16Unorm            = (R16 << 21)          | (Unorm << 27),   // 0x13600000
+            R16Snorm            = (R16 << 21)          | (Snorm << 27),   // 0x0b600000
+            R16Uint             = (R16 << 21)          | (Uint << 27),    // 0x23600000
+            R16Sint             = (R16 << 21)          | (Sint << 27),    // 0x1b600000
+            R32Float            = (R32 << 21)          | (Float << 27),   // 0x3a400000
+            R32Uint             = (R32 << 21)          | (Uint << 27),    // 0x22400000
+            R32Sint             = (R32 << 21)          | (Sint << 27),    // 0x1a400000
+            R8G8Unorm           = (R8G8 << 21)         | (Unorm << 27),   // 0x13000000
+            R8G8Snorm           = (R8G8 << 21)         | (Snorm << 27),   // 0x0b000000
+            R8G8Uint            = (R8G8 << 21)         | (Uint << 27),    // 0x23000000
+            R8G8Sint            = (R8G8 << 21)         | (Sint << 27),    // 0x1b000000
+            R16G16Float         = (R16G16 << 21)       | (Float << 27),   // 0x39e00000
+            R16G16Unorm         = (R16G16 << 21)       | (Unorm << 27),   // 0x11e00000
+            R16G16Snorm         = (R16G16 << 21)       | (Snorm << 27),   // 0x09e00000
+            R16G16Uint          = (R16G16 << 21)       | (Uint << 27),    // 0x21e00000
+            R16G16Sint          = (R16G16 << 21)       | (Sint << 27),    // 0x19e00000
+            R32G32Float         = (R32G32 << 21)       | (Float << 27),   // 0x38800000
+            R32G32Uint          = (R32G32 << 21)       | (Uint << 27),    // 0x20800000
+            R32G32Sint          = (R32G32 << 21)       | (Sint << 27),    // 0x18800000
+            R8G8B8Unorm         = (R8G8B8 << 21)       | (Unorm << 27),   // 0x12600000
+            R8G8B8Snorm         = (R8G8B8 << 21)       | (Snorm << 27),   // 0x0a600000
+            R8G8B8Uint          = (R8G8B8 << 21)       | (Uint << 27),    // 0x22600000
+            R8G8B8Sint          = (R8G8B8 << 21)       | (Sint << 27),    // 0x1a600000
+            R16G16B16Float      = (R16G16B16 << 21)    | (Float << 27),   // 0x38a00000
+            R16G16B16Unorm      = (R16G16B16 << 21)    | (Unorm << 27),   // 0x10a00000
+            R16G16B16Snorm      = (R16G16B16 << 21)    | (Snorm << 27),   // 0x08a00000
+            R16G16B16Uint       = (R16G16B16 << 21)    | (Uint << 27),    // 0x20a00000
+            R16G16B16Sint       = (R16G16B16 << 21)    | (Sint << 27),    // 0x18a00000
+            R32G32B32Float      = (R32G32B32 << 21)    | (Float << 27),   // 0x38400000
+            R32G32B32Uint       = (R32G32B32 << 21)    | (Uint << 27),    // 0x20400000
+            R32G32B32Sint       = (R32G32B32 << 21)    | (Sint << 27),    // 0x18400000
+            R8G8B8A8Unorm       = (R8G8B8A8 << 21)     | (Unorm << 27),   // 0x11400000
+            R8G8B8A8Snorm       = (R8G8B8A8 << 21)     | (Snorm << 27),   // 0x09400000
+            R8G8B8A8Uint        = (R8G8B8A8 << 21)     | (Uint << 27),    // 0x21400000
+            R8G8B8A8Sint        = (R8G8B8A8 << 21)     | (Sint << 27),    // 0x19400000
+            R16G16B16A16Float   = (R16G16B16A16 << 21) | (Float << 27),   // 0x38600000
+            R16G16B16A16Unorm   = (R16G16B16A16 << 21) | (Unorm << 27),   // 0x10600000
+            R16G16B16A16Snorm   = (R16G16B16A16 << 21) | (Snorm << 27),   // 0x08600000
+            R16G16B16A16Uint    = (R16G16B16A16 << 21) | (Uint << 27),    // 0x20600000
+            R16G16B16A16Sint    = (R16G16B16A16 << 21) | (Sint << 27),    // 0x18600000
+            R32G32B32A32Float   = (R32G32B32A32 << 21) | (Float << 27),   // 0x38200000
+            R32G32B32A32Uint    = (R32G32B32A32 << 21) | (Uint << 27),    // 0x20200000
+            R32G32B32A32Sint    = (R32G32B32A32 << 21) | (Sint << 27),    // 0x18200000
+            A2B10G10R10Unorm    = (A2B10G10R10 << 21)  | (Unorm << 27),   // 0x16000000
+            A2B10G10R10Uint     = (A2B10G10R10 << 21)  | (Uint << 27),    // 0x26000000
+            B10G11R11Float      = (B10G11R11 << 21)    | (Float << 27),   // 0x3e200000
+            R8Uscaled           = (R8 << 21)           | (Uscaled << 27), // 0x2ba00000
+            R8Sscaled           = (R8 << 21)           | (Sscaled << 27), // 0x33a00000
+            R16Uscaled          = (R16 << 21)          | (Uscaled << 27), // 0x2b600000
+            R16Sscaled          = (R16 << 21)          | (Sscaled << 27), // 0x33600000
+            R32Uscaled          = (R32 << 21)          | (Uscaled << 27), // 0x2a400000
+            R32Sscaled          = (R32 << 21)          | (Sscaled << 27), // 0x32400000
+            R8G8Uscaled         = (R8G8 << 21)         | (Uscaled << 27), // 0x2b000000
+            R8G8Sscaled         = (R8G8 << 21)         | (Sscaled << 27), // 0x33000000
+            R16G16Uscaled       = (R16G16 << 21)       | (Uscaled << 27), // 0x29e00000
+            R16G16Sscaled       = (R16G16 << 21)       | (Sscaled << 27), // 0x31e00000
+            R32G32Uscaled       = (R32G32 << 21)       | (Uscaled << 27), // 0x28800000
+            R32G32Sscaled       = (R32G32 << 21)       | (Sscaled << 27), // 0x30800000
+            R8G8B8Uscaled       = (R8G8B8 << 21)       | (Uscaled << 27), // 0x2a600000
+            R8G8B8Sscaled       = (R8G8B8 << 21)       | (Sscaled << 27), // 0x32600000
+            R16G16B16Uscaled    = (R16G16B16 << 21)    | (Uscaled << 27), // 0x28a00000
+            R16G16B16Sscaled    = (R16G16B16 << 21)    | (Sscaled << 27), // 0x30a00000
+            R32G32B32Uscaled    = (R32G32B32 << 21)    | (Uscaled << 27), // 0x28400000
+            R32G32B32Sscaled    = (R32G32B32 << 21)    | (Sscaled << 27), // 0x30400000
+            R8G8B8A8Uscaled     = (R8G8B8A8 << 21)     | (Uscaled << 27), // 0x29400000
+            R8G8B8A8Sscaled     = (R8G8B8A8 << 21)     | (Sscaled << 27), // 0x31400000
+            R16G16B16A16Uscaled = (R16G16B16A16 << 21) | (Uscaled << 27), // 0x28600000
+            R16G16B16A16Sscaled = (R16G16B16A16 << 21) | (Sscaled << 27), // 0x30600000
+            R32G32B32A32Uscaled = (R32G32B32A32 << 21) | (Uscaled << 27), // 0x28200000
+            R32G32B32A32Sscaled = (R32G32B32A32 << 21) | (Sscaled << 27), // 0x30200000
+            A2B10G10R10Snorm    = (A2B10G10R10 << 21)  | (Snorm << 27),   // 0x0e000000
+            A2B10G10R10Sint     = (A2B10G10R10 << 21)  | (Sint << 27),    // 0x1e000000
+            A2B10G10R10Uscaled  = (A2B10G10R10 << 21)  | (Uscaled << 27), // 0x2e000000
+            A2B10G10R10Sscaled  = (A2B10G10R10 << 21)  | (Sscaled << 27), // 0x36000000
+        }
+
+        private static readonly Dictionary<TextureFormat, FormatInfo> _textureFormats = new Dictionary<TextureFormat, FormatInfo>()
+        {
+            { TextureFormat.R8Unorm,                          new FormatInfo(Format.R8Unorm,           1,  1,  1,  1) },
+            { TextureFormat.R8Snorm,                          new FormatInfo(Format.R8Snorm,           1,  1,  1,  1) },
+            { TextureFormat.R8Uint,                           new FormatInfo(Format.R8Uint,            1,  1,  1,  1) },
+            { TextureFormat.R8Sint,                           new FormatInfo(Format.R8Sint,            1,  1,  1,  1) },
+            { TextureFormat.R16Float,                         new FormatInfo(Format.R16Float,          1,  1,  2,  1) },
+            { TextureFormat.R16Unorm,                         new FormatInfo(Format.R16Unorm,          1,  1,  2,  1) },
+            { TextureFormat.R16Snorm,                         new FormatInfo(Format.R16Snorm,          1,  1,  2,  1) },
+            { TextureFormat.R16Uint,                          new FormatInfo(Format.R16Uint,           1,  1,  2,  1) },
+            { TextureFormat.R16Sint,                          new FormatInfo(Format.R16Sint,           1,  1,  2,  1) },
+            { TextureFormat.R32Float,                         new FormatInfo(Format.R32Float,          1,  1,  4,  1) },
+            { TextureFormat.R32Uint,                          new FormatInfo(Format.R32Uint,           1,  1,  4,  1) },
+            { TextureFormat.R32Sint,                          new FormatInfo(Format.R32Sint,           1,  1,  4,  1) },
+            { TextureFormat.G8R8Unorm,                        new FormatInfo(Format.R8G8Unorm,         1,  1,  2,  2) },
+            { TextureFormat.G8R8Snorm,                        new FormatInfo(Format.R8G8Snorm,         1,  1,  2,  2) },
+            { TextureFormat.G8R8Uint,                         new FormatInfo(Format.R8G8Uint,          1,  1,  2,  2) },
+            { TextureFormat.G8R8Sint,                         new FormatInfo(Format.R8G8Sint,          1,  1,  2,  2) },
+            { TextureFormat.R16G16Float,                      new FormatInfo(Format.R16G16Float,       1,  1,  4,  2) },
+            { TextureFormat.R16G16Unorm,                      new FormatInfo(Format.R16G16Unorm,       1,  1,  4,  2) },
+            { TextureFormat.R16G16Snorm,                      new FormatInfo(Format.R16G16Snorm,       1,  1,  4,  2) },
+            { TextureFormat.R16G16Uint,                       new FormatInfo(Format.R16G16Uint,        1,  1,  4,  2) },
+            { TextureFormat.R16G16Sint,                       new FormatInfo(Format.R16G16Sint,        1,  1,  4,  2) },
+            { TextureFormat.R32G32Float,                      new FormatInfo(Format.R32G32Float,       1,  1,  8,  2) },
+            { TextureFormat.R32G32Uint,                       new FormatInfo(Format.R32G32Uint,        1,  1,  8,  2) },
+            { TextureFormat.R32G32Sint,                       new FormatInfo(Format.R32G32Sint,        1,  1,  8,  2) },
+            { TextureFormat.R32G32B32Float,                   new FormatInfo(Format.R32G32B32Float,    1,  1,  12, 3) },
+            { TextureFormat.R32G32B32Uint,                    new FormatInfo(Format.R32G32B32Uint,     1,  1,  12, 3) },
+            { TextureFormat.R32G32B32Sint,                    new FormatInfo(Format.R32G32B32Sint,     1,  1,  12, 3) },
+            { TextureFormat.A8B8G8R8Unorm,                    new FormatInfo(Format.R8G8B8A8Unorm,     1,  1,  4,  4) },
+            { TextureFormat.A8B8G8R8Snorm,                    new FormatInfo(Format.R8G8B8A8Snorm,     1,  1,  4,  4) },
+            { TextureFormat.A8B8G8R8Uint,                     new FormatInfo(Format.R8G8B8A8Uint,      1,  1,  4,  4) },
+            { TextureFormat.A8B8G8R8Sint,                     new FormatInfo(Format.R8G8B8A8Sint,      1,  1,  4,  4) },
+            { TextureFormat.R16G16B16A16Float,                new FormatInfo(Format.R16G16B16A16Float, 1,  1,  8,  4) },
+            { TextureFormat.R16G16B16A16Unorm,                new FormatInfo(Format.R16G16B16A16Unorm, 1,  1,  8,  4) },
+            { TextureFormat.R16G16B16A16Snorm,                new FormatInfo(Format.R16G16B16A16Snorm, 1,  1,  8,  4) },
+            { TextureFormat.R16G16B16A16Uint,                 new FormatInfo(Format.R16G16B16A16Uint,  1,  1,  8,  4) },
+            { TextureFormat.R16G16B16A16Sint,                 new FormatInfo(Format.R16G16B16A16Sint,  1,  1,  8,  4) },
+            { TextureFormat.R32G32B32A32Float,                new FormatInfo(Format.R32G32B32A32Float, 1,  1,  16, 4) },
+            { TextureFormat.R32G32B32A32Uint,                 new FormatInfo(Format.R32G32B32A32Uint,  1,  1,  16, 4) },
+            { TextureFormat.R32G32B32A32Sint,                 new FormatInfo(Format.R32G32B32A32Sint,  1,  1,  16, 4) },
+            { TextureFormat.Z16Unorm,                         new FormatInfo(Format.D16Unorm,          1,  1,  2,  1) },
+            { TextureFormat.Zf32RFloatGUintBUintAUint,        new FormatInfo(Format.D32Float,          1,  1,  4,  1) },
+            { TextureFormat.Zf32Float,                        new FormatInfo(Format.D32Float,          1,  1,  4,  1) },
+            { TextureFormat.G24R8RUintGUnormBUnormAUnorm,     new FormatInfo(Format.D24UnormS8Uint,    1,  1,  4,  2) },
+            { TextureFormat.Z24S8RUintGUnormBUnormAUnorm,     new FormatInfo(Format.D24UnormS8Uint,    1,  1,  4,  2) },
+            { TextureFormat.Z24S8RUintGUnormBUintAUint,       new FormatInfo(Format.D24UnormS8Uint,    1,  1,  4,  2) },
+            { TextureFormat.S8Z24RUnormGUintBUintAUint,       new FormatInfo(Format.S8UintD24Unorm,    1,  1,  4,  2) },
+            { TextureFormat.R32B24G8RFloatGUintBUnormAUnorm,  new FormatInfo(Format.D32FloatS8Uint,    1,  1,  8,  2) },
+            { TextureFormat.Zf32X24S8RFloatGUintBUnormAUnorm, new FormatInfo(Format.D32FloatS8Uint,    1,  1,  8,  2) },
+            { TextureFormat.A8B8G8R8UnormSrgb,                new FormatInfo(Format.R8G8B8A8Srgb,      1,  1,  4,  4) },
+            { TextureFormat.G4R4Unorm,                        new FormatInfo(Format.R4G4Unorm,         1,  1,  1,  2) },
+            { TextureFormat.A4B4G4R4Unorm,                    new FormatInfo(Format.R4G4B4A4Unorm,     1,  1,  2,  4) },
+            { TextureFormat.A1B5G5R5Unorm,                    new FormatInfo(Format.R5G5B5A1Unorm,     1,  1,  2,  4) },
+            { TextureFormat.B5G6R5Unorm,                      new FormatInfo(Format.R5G6B5Unorm,       1,  1,  2,  3) },
+            { TextureFormat.A2B10G10R10Unorm,                 new FormatInfo(Format.R10G10B10A2Unorm,  1,  1,  4,  4) },
+            { TextureFormat.A2B10G10R10Uint,                  new FormatInfo(Format.R10G10B10A2Uint,   1,  1,  4,  4) },
+            { TextureFormat.Bf10Gf11Rf11Float,                new FormatInfo(Format.R11G11B10Float,    1,  1,  4,  3) },
+            { TextureFormat.E5B9G9R9SharedExpFloat,           new FormatInfo(Format.R9G9B9E5Float,     1,  1,  4,  4) },
+            { TextureFormat.Bc1Unorm,                         new FormatInfo(Format.Bc1RgbaUnorm,      4,  4,  8,  4) },
+            { TextureFormat.Bc2Unorm,                         new FormatInfo(Format.Bc2Unorm,          4,  4,  16, 4) },
+            { TextureFormat.Bc3Unorm,                         new FormatInfo(Format.Bc3Unorm,          4,  4,  16, 4) },
+            { TextureFormat.Bc1UnormSrgb,                     new FormatInfo(Format.Bc1RgbaSrgb,       4,  4,  8,  4) },
+            { TextureFormat.Bc2UnormSrgb,                     new FormatInfo(Format.Bc2Srgb,           4,  4,  16, 4) },
+            { TextureFormat.Bc3UnormSrgb,                     new FormatInfo(Format.Bc3Srgb,           4,  4,  16, 4) },
+            { TextureFormat.Bc4Unorm,                         new FormatInfo(Format.Bc4Unorm,          4,  4,  8,  1) },
+            { TextureFormat.Bc4Snorm,                         new FormatInfo(Format.Bc4Snorm,          4,  4,  8,  1) },
+            { TextureFormat.Bc5Unorm,                         new FormatInfo(Format.Bc5Unorm,          4,  4,  16, 2) },
+            { TextureFormat.Bc5Snorm,                         new FormatInfo(Format.Bc5Snorm,          4,  4,  16, 2) },
+            { TextureFormat.Bc7UUnorm,                        new FormatInfo(Format.Bc7Unorm,          4,  4,  16, 4) },
+            { TextureFormat.Bc7UUnormSrgb,                    new FormatInfo(Format.Bc7Srgb,           4,  4,  16, 4) },
+            { TextureFormat.Bc6HSf16Float,                    new FormatInfo(Format.Bc6HSfloat,        4,  4,  16, 4) },
+            { TextureFormat.Bc6HUf16Float,                    new FormatInfo(Format.Bc6HUfloat,        4,  4,  16, 4) },
+            { TextureFormat.Etc2RgbUnorm,                     new FormatInfo(Format.Etc2RgbUnorm,      4,  4,  8,  3) },
+            { TextureFormat.Etc2RgbaUnorm,                    new FormatInfo(Format.Etc2RgbaUnorm,     4,  4,  16, 4) },
+            { TextureFormat.Etc2RgbUnormSrgb,                 new FormatInfo(Format.Etc2RgbSrgb,       4,  4,  8,  3) },
+            { TextureFormat.Etc2RgbaUnormSrgb,                new FormatInfo(Format.Etc2RgbaSrgb,      4,  4,  16, 4) },
+            { TextureFormat.Astc2D4x4Unorm,                   new FormatInfo(Format.Astc4x4Unorm,      4,  4,  16, 4) },
+            { TextureFormat.Astc2D5x4Unorm,                   new FormatInfo(Format.Astc5x4Unorm,      5,  4,  16, 4) },
+            { TextureFormat.Astc2D5x5Unorm,                   new FormatInfo(Format.Astc5x5Unorm,      5,  5,  16, 4) },
+            { TextureFormat.Astc2D6x5Unorm,                   new FormatInfo(Format.Astc6x5Unorm,      6,  5,  16, 4) },
+            { TextureFormat.Astc2D6x6Unorm,                   new FormatInfo(Format.Astc6x6Unorm,      6,  6,  16, 4) },
+            { TextureFormat.Astc2D8x5Unorm,                   new FormatInfo(Format.Astc8x5Unorm,      8,  5,  16, 4) },
+            { TextureFormat.Astc2D8x6Unorm,                   new FormatInfo(Format.Astc8x6Unorm,      8,  6,  16, 4) },
+            { TextureFormat.Astc2D8x8Unorm,                   new FormatInfo(Format.Astc8x8Unorm,      8,  8,  16, 4) },
+            { TextureFormat.Astc2D10x5Unorm,                  new FormatInfo(Format.Astc10x5Unorm,     10, 5,  16, 4) },
+            { TextureFormat.Astc2D10x6Unorm,                  new FormatInfo(Format.Astc10x6Unorm,     10, 6,  16, 4) },
+            { TextureFormat.Astc2D10x8Unorm,                  new FormatInfo(Format.Astc10x8Unorm,     10, 8,  16, 4) },
+            { TextureFormat.Astc2D10x10Unorm,                 new FormatInfo(Format.Astc10x10Unorm,    10, 10, 16, 4) },
+            { TextureFormat.Astc2D12x10Unorm,                 new FormatInfo(Format.Astc12x10Unorm,    12, 10, 16, 4) },
+            { TextureFormat.Astc2D12x12Unorm,                 new FormatInfo(Format.Astc12x12Unorm,    12, 12, 16, 4) },
+            { TextureFormat.Astc2D4x4UnormSrgb,               new FormatInfo(Format.Astc4x4Srgb,       4,  4,  16, 4) },
+            { TextureFormat.Astc2D5x4UnormSrgb,               new FormatInfo(Format.Astc5x4Srgb,       5,  4,  16, 4) },
+            { TextureFormat.Astc2D5x5UnormSrgb,               new FormatInfo(Format.Astc5x5Srgb,       5,  5,  16, 4) },
+            { TextureFormat.Astc2D6x5UnormSrgb,               new FormatInfo(Format.Astc6x5Srgb,       6,  5,  16, 4) },
+            { TextureFormat.Astc2D6x6UnormSrgb,               new FormatInfo(Format.Astc6x6Srgb,       6,  6,  16, 4) },
+            { TextureFormat.Astc2D8x5UnormSrgb,               new FormatInfo(Format.Astc8x5Srgb,       8,  5,  16, 4) },
+            { TextureFormat.Astc2D8x6UnormSrgb,               new FormatInfo(Format.Astc8x6Srgb,       8,  6,  16, 4) },
+            { TextureFormat.Astc2D8x8UnormSrgb,               new FormatInfo(Format.Astc8x8Srgb,       8,  8,  16, 4) },
+            { TextureFormat.Astc2D10x5UnormSrgb,              new FormatInfo(Format.Astc10x5Srgb,      10, 5,  16, 4) },
+            { TextureFormat.Astc2D10x6UnormSrgb,              new FormatInfo(Format.Astc10x6Srgb,      10, 6,  16, 4) },
+            { TextureFormat.Astc2D10x8UnormSrgb,              new FormatInfo(Format.Astc10x8Srgb,      10, 8,  16, 4) },
+            { TextureFormat.Astc2D10x10UnormSrgb,             new FormatInfo(Format.Astc10x10Srgb,     10, 10, 16, 4) },
+            { TextureFormat.Astc2D12x10UnormSrgb,             new FormatInfo(Format.Astc12x10Srgb,     12, 10, 16, 4) },
+            { TextureFormat.Astc2D12x12UnormSrgb,             new FormatInfo(Format.Astc12x12Srgb,     12, 12, 16, 4) },
+            { TextureFormat.A5B5G5R1Unorm,                    new FormatInfo(Format.A1B5G5R5Unorm,     1,  1,  2,  4) }
        };

-        private static Dictionary<ulong, Format> _attribFormats = new Dictionary<ulong, Format>()
+        private static readonly Dictionary<VertexAttributeFormat, Format> _attribFormats = new Dictionary<VertexAttributeFormat, Format>()
        {
-            { 0x13a00000, Format.R8Unorm             },
-            { 0x0ba00000, Format.R8Snorm             },
-            { 0x23a00000, Format.R8Uint              },
-            { 0x1ba00000, Format.R8Sint              },
-            { 0x3b600000, Format.R16Float            },
-            { 0x13600000, Format.R16Unorm            },
-            { 0x0b600000, Format.R16Snorm            },
-            { 0x23600000, Format.R16Uint             },
-            { 0x1b600000, Format.R16Sint             },
-            { 0x3a400000, Format.R32Float            },
-            { 0x22400000, Format.R32Uint             },
-            { 0x1a400000, Format.R32Sint             },
-            { 0x13000000, Format.R8G8Unorm           },
-            { 0x0b000000, Format.R8G8Snorm           },
-            { 0x23000000, Format.R8G8Uint            },
-            { 0x1b000000, Format.R8G8Sint            },
-            { 0x39e00000, Format.R16G16Float         },
-            { 0x11e00000, Format.R16G16Unorm         },
-            { 0x09e00000, Format.R16G16Snorm         },
-            { 0x21e00000, Format.R16G16Uint          },
-            { 0x19e00000, Format.R16G16Sint          },
-            { 0x38800000, Format.R32G32Float         },
-            { 0x20800000, Format.R32G32Uint          },
-            { 0x18800000, Format.R32G32Sint          },
-            { 0x12600000, Format.R8G8B8Unorm         },
-            { 0x0a600000, Format.R8G8B8Snorm         },
-            { 0x22600000, Format.R8G8B8Uint          },
-            { 0x1a600000, Format.R8G8B8Sint          },
-            { 0x38a00000, Format.R16G16B16Float      },
-            { 0x10a00000, Format.R16G16B16Unorm      },
-            { 0x08a00000, Format.R16G16B16Snorm      },
-            { 0x20a00000, Format.R16G16B16Uint       },
-            { 0x18a00000, Format.R16G16B16Sint       },
-            { 0x38400000, Format.R32G32B32Float      },
-            { 0x20400000, Format.R32G32B32Uint       },
-            { 0x18400000, Format.R32G32B32Sint       },
-            { 0x11400000, Format.R8G8B8A8Unorm       },
-            { 0x09400000, Format.R8G8B8A8Snorm       },
-            { 0x21400000, Format.R8G8B8A8Uint        },
-            { 0x19400000, Format.R8G8B8A8Sint        },
-            { 0x38600000, Format.R16G16B16A16Float   },
-            { 0x10600000, Format.R16G16B16A16Unorm   },
-            { 0x08600000, Format.R16G16B16A16Snorm   },
-            { 0x20600000, Format.R16G16B16A16Uint    },
-            { 0x18600000, Format.R16G16B16A16Sint    },
-            { 0x38200000, Format.R32G32B32A32Float   },
-            { 0x20200000, Format.R32G32B32A32Uint    },
-            { 0x18200000, Format.R32G32B32A32Sint    },
-            { 0x16000000, Format.R10G10B10A2Unorm    },
-            { 0x26000000, Format.R10G10B10A2Uint     },
-            { 0x3e200000, Format.R11G11B10Float      },
-            { 0x2ba00000, Format.R8Uscaled           },
-            { 0x33a00000, Format.R8Sscaled           },
-            { 0x2b600000, Format.R16Uscaled          },
-            { 0x33600000, Format.R16Sscaled          },
-            { 0x2a400000, Format.R32Uscaled          },
-            { 0x32400000, Format.R32Sscaled          },
-            { 0x2b000000, Format.R8G8Uscaled         },
-            { 0x33000000, Format.R8G8Sscaled         },
-            { 0x29e00000, Format.R16G16Uscaled       },
-            { 0x31e00000, Format.R16G16Sscaled       },
-            { 0x28800000, Format.R32G32Uscaled       },
-            { 0x30800000, Format.R32G32Sscaled       },
-            { 0x2a600000, Format.R8G8B8Uscaled       },
-            { 0x32600000, Format.R8G8B8Sscaled       },
-            { 0x28a00000, Format.R16G16B16Uscaled    },
-            { 0x30a00000, Format.R16G16B16Sscaled    },
-            { 0x28400000, Format.R32G32B32Uscaled    },
-            { 0x30400000, Format.R32G32B32Sscaled    },
-            { 0x29400000, Format.R8G8B8A8Uscaled     },
-            { 0x31400000, Format.R8G8B8A8Sscaled     },
-            { 0x28600000, Format.R16G16B16A16Uscaled },
-            { 0x30600000, Format.R16G16B16A16Sscaled },
-            { 0x28200000, Format.R32G32B32A32Uscaled },
-            { 0x30200000, Format.R32G32B32A32Sscaled },
-            { 0x0e000000, Format.R10G10B10A2Snorm    },
-            { 0x1e000000, Format.R10G10B10A2Sint     },
-            { 0x2e000000, Format.R10G10B10A2Uscaled  },
-            { 0x36000000, Format.R10G10B10A2Sscaled  }
+            { VertexAttributeFormat.R8Unorm,             Format.R8Unorm             },
+            { VertexAttributeFormat.R8Snorm,             Format.R8Snorm             },
+            { VertexAttributeFormat.R8Uint,              Format.R8Uint              },
+            { VertexAttributeFormat.R8Sint,              Format.R8Sint              },
+            { VertexAttributeFormat.R16Float,            Format.R16Float            },
+            { VertexAttributeFormat.R16Unorm,            Format.R16Unorm            },
+            { VertexAttributeFormat.R16Snorm,            Format.R16Snorm            },
+            { VertexAttributeFormat.R16Uint,             Format.R16Uint             },
+            { VertexAttributeFormat.R16Sint,             Format.R16Sint             },
+            { VertexAttributeFormat.R32Float,            Format.R32Float            },
+            { VertexAttributeFormat.R32Uint,             Format.R32Uint             },
+            { VertexAttributeFormat.R32Sint,             Format.R32Sint             },
+            { VertexAttributeFormat.R8G8Unorm,           Format.R8G8Unorm           },
+            { VertexAttributeFormat.R8G8Snorm,           Format.R8G8Snorm           },
+            { VertexAttributeFormat.R8G8Uint,            Format.R8G8Uint            },
+            { VertexAttributeFormat.R8G8Sint,            Format.R8G8Sint            },
+            { VertexAttributeFormat.R16G16Float,         Format.R16G16Float         },
+            { VertexAttributeFormat.R16G16Unorm,         Format.R16G16Unorm         },
+            { VertexAttributeFormat.R16G16Snorm,         Format.R16G16Snorm         },
+            { VertexAttributeFormat.R16G16Uint,          Format.R16G16Uint          },
+            { VertexAttributeFormat.R16G16Sint,          Format.R16G16Sint          },
+            { VertexAttributeFormat.R32G32Float,         Format.R32G32Float         },
+            { VertexAttributeFormat.R32G32Uint,          Format.R32G32Uint          },
+            { VertexAttributeFormat.R32G32Sint,          Format.R32G32Sint          },
+            { VertexAttributeFormat.R8G8B8Unorm,         Format.R8G8B8Unorm         },
+            { VertexAttributeFormat.R8G8B8Snorm,         Format.R8G8B8Snorm         },
+            { VertexAttributeFormat.R8G8B8Uint,          Format.R8G8B8Uint          },
+            { VertexAttributeFormat.R8G8B8Sint,          Format.R8G8B8Sint          },
+            { VertexAttributeFormat.R16G16B16Float,      Format.R16G16B16Float      },
+            { VertexAttributeFormat.R16G16B16Unorm,      Format.R16G16B16Unorm      },
+            { VertexAttributeFormat.R16G16B16Snorm,      Format.R16G16B16Snorm      },
+            { VertexAttributeFormat.R16G16B16Uint,       Format.R16G16B16Uint       },
+            { VertexAttributeFormat.R16G16B16Sint,       Format.R16G16B16Sint       },
+            { VertexAttributeFormat.R32G32B32Float,      Format.R32G32B32Float      },
+            { VertexAttributeFormat.R32G32B32Uint,       Format.R32G32B32Uint       },
+            { VertexAttributeFormat.R32G32B32Sint,       Format.R32G32B32Sint       },
+            { VertexAttributeFormat.R8G8B8A8Unorm,       Format.R8G8B8A8Unorm       },
+            { VertexAttributeFormat.R8G8B8A8Snorm,       Format.R8G8B8A8Snorm       },
+            { VertexAttributeFormat.R8G8B8A8Uint,        Format.R8G8B8A8Uint        },
+            { VertexAttributeFormat.R8G8B8A8Sint,        Format.R8G8B8A8Sint        },
+            { VertexAttributeFormat.R16G16B16A16Float,   Format.R16G16B16A16Float   },
+            { VertexAttributeFormat.R16G16B16A16Unorm,   Format.R16G16B16A16Unorm   },
+            { VertexAttributeFormat.R16G16B16A16Snorm,   Format.R16G16B16A16Snorm   },
+            { VertexAttributeFormat.R16G16B16A16Uint,    Format.R16G16B16A16Uint    },
+            { VertexAttributeFormat.R16G16B16A16Sint,    Format.R16G16B16A16Sint    },
+            { VertexAttributeFormat.R32G32B32A32Float,   Format.R32G32B32A32Float   },
+            { VertexAttributeFormat.R32G32B32A32Uint,    Format.R32G32B32A32Uint    },
+            { VertexAttributeFormat.R32G32B32A32Sint,    Format.R32G32B32A32Sint    },
+            { VertexAttributeFormat.A2B10G10R10Unorm,    Format.R10G10B10A2Unorm    },
+            { VertexAttributeFormat.A2B10G10R10Uint,     Format.R10G10B10A2Uint     },
+            { VertexAttributeFormat.B10G11R11Float,      Format.R11G11B10Float      },
+            { VertexAttributeFormat.R8Uscaled,           Format.R8Uscaled           },
+            { VertexAttributeFormat.R8Sscaled,           Format.R8Sscaled           },
+            { VertexAttributeFormat.R16Uscaled,          Format.R16Uscaled          },
+            { VertexAttributeFormat.R16Sscaled,          Format.R16Sscaled          },
+            { VertexAttributeFormat.R32Uscaled,          Format.R32Uscaled          },
+            { VertexAttributeFormat.R32Sscaled,          Format.R32Sscaled          },
+            { VertexAttributeFormat.R8G8Uscaled,         Format.R8G8Uscaled         },
+            { VertexAttributeFormat.R8G8Sscaled,         Format.R8G8Sscaled         },
+            { VertexAttributeFormat.R16G16Uscaled,       Format.R16G16Uscaled       },
+            { VertexAttributeFormat.R16G16Sscaled,       Format.R16G16Sscaled       },
+            { VertexAttributeFormat.R32G32Uscaled,       Format.R32G32Uscaled       },
+            { VertexAttributeFormat.R32G32Sscaled,       Format.R32G32Sscaled       },
+            { VertexAttributeFormat.R8G8B8Uscaled,       Format.R8G8B8Uscaled       },
+            { VertexAttributeFormat.R8G8B8Sscaled,       Format.R8G8B8Sscaled       },
+            { VertexAttributeFormat.R16G16B16Uscaled,    Format.R16G16B16Uscaled    },
+            { VertexAttributeFormat.R16G16B16Sscaled,    Format.R16G16B16Sscaled    },
+            { VertexAttributeFormat.R32G32B32Uscaled,    Format.R32G32B32Uscaled    },
+            { VertexAttributeFormat.R32G32B32Sscaled,    Format.R32G32B32Sscaled    },
+            { VertexAttributeFormat.R8G8B8A8Uscaled,     Format.R8G8B8A8Uscaled     },
+            { VertexAttributeFormat.R8G8B8A8Sscaled,     Format.R8G8B8A8Sscaled     },
+            { VertexAttributeFormat.R16G16B16A16Uscaled, Format.R16G16B16A16Uscaled },
+            { VertexAttributeFormat.R16G16B16A16Sscaled, Format.R16G16B16A16Sscaled },
+            { VertexAttributeFormat.R32G32B32A32Uscaled, Format.R32G32B32A32Uscaled },
+            { VertexAttributeFormat.R32G32B32A32Sscaled, Format.R32G32B32A32Sscaled },
+            { VertexAttributeFormat.A2B10G10R10Snorm,    Format.R10G10B10A2Snorm    },
+            { VertexAttributeFormat.A2B10G10R10Sint,     Format.R10G10B10A2Sint     },
+            { VertexAttributeFormat.A2B10G10R10Uscaled,  Format.R10G10B10A2Uscaled  },
+            { VertexAttributeFormat.A2B10G10R10Sscaled,  Format.R10G10B10A2Sscaled  }
        };

        /// <summary>
@@ -210,7 +557,7 @@ namespace Ryujinx.Graphics.Gpu.Image
        {
            encoded |= (isSrgb ? 1u << 19 : 0u);

-            return _textureFormats.TryGetValue(encoded, out format);
+            return _textureFormats.TryGetValue((TextureFormat)encoded, out format);
        }

        /// <summary>
@@ -221,7 +568,7 @@ namespace Ryujinx.Graphics.Gpu.Image
        /// <returns>True if the format is valid, false otherwise</returns>
        public static bool TryGetAttribFormat(uint encoded, out Format format)
        {
-            return _attribFormats.TryGetValue(encoded, out format);
+            return _attribFormats.TryGetValue((VertexAttributeFormat)encoded, out format);
        }
    }
 }
--- a/Ryujinx.HLE/HOS/Kernel/Memory/KMemoryBlock.cs
+++ b/Ryujinx.HLE/HOS/Kernel/Memory/KMemoryBlock.cs
@@ -1,42 +1,43 @@
+using Ryujinx.Common.Collections;
 using System;

 namespace Ryujinx.HLE.HOS.Kernel.Memory
 {
-    class KMemoryBlock
+    class KMemoryBlock : IntrusiveRedBlackTreeNode<KMemoryBlock>, IComparable<KMemoryBlock>, IComparable<ulong>
    {
        public ulong BaseAddress { get; private set; }
-        public ulong PagesCount  { get; private set; }
+        public ulong PagesCount { get; private set; }

-        public MemoryState      State            { get; private set; }
-        public KMemoryPermission Permission       { get; private set; }
-        public MemoryAttribute  Attribute        { get; private set; }
+        public MemoryState State { get; private set; }
+        public KMemoryPermission Permission { get; private set; }
+        public MemoryAttribute Attribute { get; private set; }
        public KMemoryPermission SourcePermission { get; private set; }

-        public int IpcRefCount    { get; private set; }
+        public int IpcRefCount { get; private set; }
        public int DeviceRefCount { get; private set; }

        public KMemoryBlock(
-            ulong            baseAddress,
-            ulong            pagesCount,
-            MemoryState      state,
+            ulong baseAddress,
+            ulong pagesCount,
+            MemoryState state,
            KMemoryPermission permission,
-            MemoryAttribute  attribute,
-            int              ipcRefCount    = 0,
-            int              deviceRefCount = 0)
+            MemoryAttribute attribute,
+            int ipcRefCount = 0,
+            int deviceRefCount = 0)
        {
-            BaseAddress    = baseAddress;
-            PagesCount     = pagesCount;
-            State          = state;
-            Attribute      = attribute;
-            Permission     = permission;
-            IpcRefCount    = ipcRefCount;
+            BaseAddress = baseAddress;
+            PagesCount = pagesCount;
+            State = state;
+            Attribute = attribute;
+            Permission = permission;
+            IpcRefCount = ipcRefCount;
            DeviceRefCount = deviceRefCount;
        }

        public void SetState(KMemoryPermission permission, MemoryState state, MemoryAttribute attribute)
        {
            Permission = permission;
-            State      = state;
+            State = state;
            Attribute &= MemoryAttribute.IpcAndDeviceMapped;
            Attribute |= attribute;
        }
@@ -55,7 +56,7 @@ namespace Ryujinx.HLE.HOS.Kernel.Memory
                SourcePermission = Permission;

                Permission &= ~KMemoryPermission.ReadAndWrite;
-                Permission |=  KMemoryPermission.ReadAndWrite & newPermission;
+                Permission |= KMemoryPermission.ReadAndWrite & newPermission;
            }

            Attribute |= MemoryAttribute.IpcMapped;
@@ -119,5 +120,37 @@ namespace Ryujinx.HLE.HOS.Kernel.Memory
                IpcRefCount,
                DeviceRefCount);
        }
+
+        public int CompareTo(KMemoryBlock other)
+        {
+            if (BaseAddress < other.BaseAddress)
+            {
+                return -1;
+            }
+            else if (BaseAddress <= other.BaseAddress + other.PagesCount * KPageTableBase.PageSize - 1UL)
+            {
+                return 0;
+            }
+            else
+            {
+                return 1;
+            }
+        }
+
+        public int CompareTo(ulong address)
+        {
+            if (address < BaseAddress)
+            {
+                return 1;
+            }
+            else if (address <= BaseAddress + PagesCount * KPageTableBase.PageSize - 1UL)
+            {
+                return 0;
+            }
+            else
+            {
+                return -1;
+            }
+        }
    }
 }
--- a/Ryujinx.HLE/HOS/Kernel/Memory/KMemoryBlockManager.cs
+++ b/Ryujinx.HLE/HOS/Kernel/Memory/KMemoryBlockManager.cs
@@ -1,5 +1,5 @@
-using Ryujinx.HLE.HOS.Kernel.Common;
-using System.Collections.Generic;
+using Ryujinx.Common.Collections;
+using Ryujinx.HLE.HOS.Kernel.Common;
 using System.Diagnostics;

 namespace Ryujinx.HLE.HOS.Kernel.Memory
@@ -8,26 +8,27 @@ namespace Ryujinx.HLE.HOS.Kernel.Memory
    {
        private const int PageSize = KPageTableBase.PageSize;

-        private readonly LinkedList<KMemoryBlock> _blocks;
+        private readonly IntrusiveRedBlackTree<KMemoryBlock> _blockTree;

-        public int BlocksCount => _blocks.Count;
+        public int BlocksCount => _blockTree.Count;

        private KMemoryBlockSlabManager _slabManager;

+        private ulong _addrSpaceStart;
        private ulong _addrSpaceEnd;

        public KMemoryBlockManager()
        {
-            _blocks = new LinkedList<KMemoryBlock>();
+            _blockTree = new IntrusiveRedBlackTree<KMemoryBlock>();
        }

        public KernelResult Initialize(ulong addrSpaceStart, ulong addrSpaceEnd, KMemoryBlockSlabManager slabManager)
        {
            _slabManager = slabManager;
+            _addrSpaceStart = addrSpaceStart;
            _addrSpaceEnd = addrSpaceEnd;

-            // First insertion will always need only a single block,
-            // because there's nothing else to split.
+            // First insertion will always need only a single block, because there's nothing to split.
            if (!slabManager.CanAllocate(1))
            {
                return KernelResult.OutOfResource;
@@ -35,7 +36,7 @@ namespace Ryujinx.HLE.HOS.Kernel.Memory

            ulong addrSpacePagesCount = (addrSpaceEnd - addrSpaceStart) / PageSize;

-            _blocks.AddFirst(new KMemoryBlock(
+            _blockTree.Add(new KMemoryBlock(
                addrSpaceStart,
                addrSpacePagesCount,
                MemoryState.Unmapped,
@@ -58,20 +59,17 @@ namespace Ryujinx.HLE.HOS.Kernel.Memory
            // Insert new block on the list only on areas where the state
            // of the block matches the state specified on the old* state
            // arguments, otherwise leave it as is.
-            int oldCount = _blocks.Count;
+
+            int oldCount = _blockTree.Count;

            oldAttribute |= MemoryAttribute.IpcAndDeviceMapped;

            ulong endAddr = baseAddress + pagesCount * PageSize;

-            LinkedListNode<KMemoryBlock> node = _blocks.First;
+            KMemoryBlock currBlock = FindBlock(baseAddress);

-            while (node != null)
+            while (currBlock != null)
            {
-                LinkedListNode<KMemoryBlock> newNode = node;
-
-                KMemoryBlock currBlock = node.Value;
-
                ulong currBaseAddr = currBlock.BaseAddress;
                ulong currEndAddr = currBlock.PagesCount * PageSize + currBaseAddr;

@@ -83,24 +81,27 @@ namespace Ryujinx.HLE.HOS.Kernel.Memory
                        currBlock.Permission != oldPermission ||
                        currBlockAttr != oldAttribute)
                    {
-                        node = node.Next;
+                        currBlock = currBlock.Successor;

                        continue;
                    }

                    if (baseAddress > currBaseAddr)
                    {
-                        _blocks.AddBefore(node, currBlock.SplitRightAtAddress(baseAddress));
+                        KMemoryBlock newBlock = currBlock.SplitRightAtAddress(baseAddress);
+                        _blockTree.Add(newBlock);
                    }

                    if (endAddr < currEndAddr)
                    {
-                        newNode = _blocks.AddBefore(node, currBlock.SplitRightAtAddress(endAddr));
+                        KMemoryBlock newBlock = currBlock.SplitRightAtAddress(endAddr);
+                        _blockTree.Add(newBlock);
+                        currBlock = newBlock;
                    }

-                    newNode.Value.SetState(newPermission, newState, newAttribute);
+                    currBlock.SetState(newPermission, newState, newAttribute);

-                    newNode = MergeEqualStateNeighbors(newNode);
+                    currBlock = MergeEqualStateNeighbors(currBlock);
                }

                if (currEndAddr - 1 >= endAddr - 1)
@@ -108,10 +109,10 @@ namespace Ryujinx.HLE.HOS.Kernel.Memory
                    break;
                }

-                node = newNode.Next;
+                currBlock = currBlock.Successor;
            }

-            _slabManager.Count += _blocks.Count - oldCount;
+            _slabManager.Count += _blockTree.Count - oldCount;

            ValidateInternalState();
        }
@@ -125,18 +126,15 @@ namespace Ryujinx.HLE.HOS.Kernel.Memory
        {
            // Inserts new block at the list, replacing and splitting
            // existing blocks as needed.
-            int oldCount = _blocks.Count;
+
+            int oldCount = _blockTree.Count;

            ulong endAddr = baseAddress + pagesCount * PageSize;

-            LinkedListNode<KMemoryBlock> node = _blocks.First;
+            KMemoryBlock currBlock = FindBlock(baseAddress);

-            while (node != null)
+            while (currBlock != null)
            {
-                LinkedListNode<KMemoryBlock> newNode = node;
-
-                KMemoryBlock currBlock = node.Value;
-
                ulong currBaseAddr = currBlock.BaseAddress;
                ulong currEndAddr = currBlock.PagesCount * PageSize + currBaseAddr;

@@ -144,17 +142,20 @@ namespace Ryujinx.HLE.HOS.Kernel.Memory
                {
                    if (baseAddress > currBaseAddr)
                    {
-                        _blocks.AddBefore(node, currBlock.SplitRightAtAddress(baseAddress));
+                        KMemoryBlock newBlock = currBlock.SplitRightAtAddress(baseAddress);
+                        _blockTree.Add(newBlock);
                    }

                    if (endAddr < currEndAddr)
                    {
-                        newNode = _blocks.AddBefore(node, currBlock.SplitRightAtAddress(endAddr));
+                        KMemoryBlock newBlock = currBlock.SplitRightAtAddress(endAddr);
+                        _blockTree.Add(newBlock);
+                        currBlock = newBlock;
                    }

-                    newNode.Value.SetState(permission, state, attribute);
+                    currBlock.SetState(permission, state, attribute);

-                    newNode = MergeEqualStateNeighbors(newNode);
+                    currBlock = MergeEqualStateNeighbors(currBlock);
                }

                if (currEndAddr - 1 >= endAddr - 1)
@@ -162,10 +163,10 @@ namespace Ryujinx.HLE.HOS.Kernel.Memory
                    break;
                }

-                node = newNode.Next;
+                currBlock = currBlock.Successor;
            }

-            _slabManager.Count += _blocks.Count - oldCount;
+            _slabManager.Count += _blockTree.Count - oldCount;

            ValidateInternalState();
        }
@@ -181,18 +182,15 @@ namespace Ryujinx.HLE.HOS.Kernel.Memory
            // Inserts new block at the list, replacing and splitting
            // existing blocks as needed, then calling the callback
            // function on the new block.
-            int oldCount = _blocks.Count;
+
+            int oldCount = _blockTree.Count;

            ulong endAddr = baseAddress + pagesCount * PageSize;

-            LinkedListNode<KMemoryBlock> node = _blocks.First;
+            KMemoryBlock currBlock = FindBlock(baseAddress);

-            while (node != null)
+            while (currBlock != null)
            {
-                LinkedListNode<KMemoryBlock> newNode = node;
-
-                KMemoryBlock currBlock = node.Value;
-
                ulong currBaseAddr = currBlock.BaseAddress;
                ulong currEndAddr = currBlock.PagesCount * PageSize + currBaseAddr;

@@ -200,19 +198,20 @@ namespace Ryujinx.HLE.HOS.Kernel.Memory
                {
                    if (baseAddress > currBaseAddr)
                    {
-                        _blocks.AddBefore(node, currBlock.SplitRightAtAddress(baseAddress));
+                        KMemoryBlock newBlock = currBlock.SplitRightAtAddress(baseAddress);
+                        _blockTree.Add(newBlock);
                    }

                    if (endAddr < currEndAddr)
                    {
-                        newNode = _blocks.AddBefore(node, currBlock.SplitRightAtAddress(endAddr));
+                        KMemoryBlock newBlock = currBlock.SplitRightAtAddress(endAddr);
+                        _blockTree.Add(newBlock);
+                        currBlock = newBlock;
                    }

-                    KMemoryBlock newBlock = newNode.Value;
+                    blockMutate(currBlock, permission);

-                    blockMutate(newBlock, permission);
-
-                    newNode = MergeEqualStateNeighbors(newNode);
+                    currBlock = MergeEqualStateNeighbors(currBlock);
                }

                if (currEndAddr - 1 >= endAddr - 1)
@@ -220,10 +219,10 @@ namespace Ryujinx.HLE.HOS.Kernel.Memory
                    break;
                }

-                node = newNode.Next;
+                currBlock = currBlock.Successor;
            }

-            _slabManager.Count += _blocks.Count - oldCount;
+            _slabManager.Count += _blockTree.Count - oldCount;

            ValidateInternalState();
        }
@@ -233,58 +232,42 @@ namespace Ryujinx.HLE.HOS.Kernel.Memory
        {
            ulong expectedAddress = 0;

-            LinkedListNode<KMemoryBlock> node = _blocks.First;
+            KMemoryBlock currBlock = FindBlock(_addrSpaceStart);

-            while (node != null)
+            while (currBlock != null)
            {
-                LinkedListNode<KMemoryBlock> newNode = node;
-
-                KMemoryBlock currBlock = node.Value;
-
                Debug.Assert(currBlock.BaseAddress == expectedAddress);

                expectedAddress = currBlock.BaseAddress + currBlock.PagesCount * PageSize;

-                node = newNode.Next;
+                currBlock = currBlock.Successor;
            }

            Debug.Assert(expectedAddress == _addrSpaceEnd);
        }

-        private LinkedListNode<KMemoryBlock> MergeEqualStateNeighbors(LinkedListNode<KMemoryBlock> node)
+        private KMemoryBlock MergeEqualStateNeighbors(KMemoryBlock block)
        {
-            KMemoryBlock block = node.Value;
+            KMemoryBlock previousBlock = block.Predecessor;
+            KMemoryBlock nextBlock = block.Successor;

-            if (node.Previous != null)
+            if (previousBlock != null && BlockStateEquals(block, previousBlock))
            {
-                KMemoryBlock previousBlock = node.Previous.Value;
+                _blockTree.Remove(block);

-                if (BlockStateEquals(block, previousBlock))
-                {
-                    LinkedListNode<KMemoryBlock> previousNode = node.Previous;
+                previousBlock.AddPages(block.PagesCount);

-                    _blocks.Remove(node);
-
-                    previousBlock.AddPages(block.PagesCount);
-
-                    node = previousNode;
-                    block = previousBlock;
-                }
+                block = previousBlock;
            }

-            if (node.Next != null)
+            if (nextBlock != null && BlockStateEquals(block, nextBlock))
            {
-                KMemoryBlock nextBlock = node.Next.Value;
+                _blockTree.Remove(nextBlock);

-                if (BlockStateEquals(block, nextBlock))
-                {
-                    _blocks.Remove(node.Next);
-
-                    block.AddPages(nextBlock.PagesCount);
-                }
+                block.AddPages(nextBlock.PagesCount);
            }

-            return node;
+            return block;
        }

        private static bool BlockStateEquals(KMemoryBlock lhs, KMemoryBlock rhs)
@@ -299,31 +282,7 @@ namespace Ryujinx.HLE.HOS.Kernel.Memory

        public KMemoryBlock FindBlock(ulong address)
        {
-            return FindBlockNode(address)?.Value;
-        }
-
-        public LinkedListNode<KMemoryBlock> FindBlockNode(ulong address)
-        {
-            lock (_blocks)
-            {
-                LinkedListNode<KMemoryBlock> node = _blocks.First;
-
-                while (node != null)
-                {
-                    KMemoryBlock block = node.Value;
-
-                    ulong currEndAddr = block.PagesCount * PageSize + block.BaseAddress;
-
-                    if (block.BaseAddress <= address && currEndAddr - 1 >= address)
-                    {
-                        return node;
-                    }
-
-                    node = node.Next;
-                }
-            }
-
-            return null;
+            return _blockTree.GetNodeByKey(address);
        }
    }
 }
--- a/Ryujinx.HLE/HOS/Kernel/Memory/KPageTableBase.cs
+++ b/Ryujinx.HLE/HOS/Kernel/Memory/KPageTableBase.cs
@@ -2447,9 +2447,9 @@ namespace Ryujinx.HLE.HOS.Kernel.Memory
        {
            ulong endAddr = address + size;

-            LinkedListNode<KMemoryBlock> node = _blockManager.FindBlockNode(address);
+            KMemoryBlock currBlock = _blockManager.FindBlock(address);

-            KMemoryInfo info = node.Value.GetInfo();
+            KMemoryInfo info = currBlock.GetInfo();

            MemoryState firstState = info.State;
            KMemoryPermission firstPermission = info.Permission;
@@ -2457,7 +2457,7 @@ namespace Ryujinx.HLE.HOS.Kernel.Memory

            do
            {
-                info = node.Value.GetInfo();
+                info = currBlock.GetInfo();

                // Check if the block state matches what we expect.
                if (firstState != info.State ||
@@ -2474,7 +2474,7 @@ namespace Ryujinx.HLE.HOS.Kernel.Memory
                    return false;
                }
            }
-            while (info.Address + info.Size - 1 < endAddr - 1 && (node = node.Next) != null);
+            while (info.Address + info.Size - 1 < endAddr - 1 && (currBlock = currBlock.Successor) != null);

            outState = firstState;
            outPermission = firstPermission;
@@ -2509,17 +2509,17 @@ namespace Ryujinx.HLE.HOS.Kernel.Memory

        private IEnumerable<KMemoryInfo> IterateOverRange(ulong start, ulong end)
        {
-            LinkedListNode<KMemoryBlock> node = _blockManager.FindBlockNode(start);
+            KMemoryBlock currBlock = _blockManager.FindBlock(start);

            KMemoryInfo info;

            do
            {
-                info = node.Value.GetInfo();
+                info = currBlock.GetInfo();

                yield return info;
            }
-            while (info.Address + info.Size - 1 < end - 1 && (node = node.Next) != null);
+            while (info.Address + info.Size - 1 < end - 1 && (currBlock = currBlock.Successor) != null);
        }

        private ulong AllocateVa(ulong regionStart, ulong regionPagesCount, ulong neededPagesCount, int alignment)
@@ -2605,9 +2605,9 @@ namespace Ryujinx.HLE.HOS.Kernel.Memory

            ulong regionEndAddr = regionStart + regionPagesCount * PageSize;

-            LinkedListNode<KMemoryBlock> node = _blockManager.FindBlockNode(regionStart);
+            KMemoryBlock currBlock = _blockManager.FindBlock(regionStart);

-            KMemoryInfo info = node.Value.GetInfo();
+            KMemoryInfo info = currBlock.GetInfo();

            while (regionEndAddr >= info.Address)
            {
@@ -2636,14 +2636,14 @@ namespace Ryujinx.HLE.HOS.Kernel.Memory
                    }
                }

-                node = node.Next;
+                currBlock = currBlock.Successor;

-                if (node == null)
+                if (currBlock == null)
                {
                    break;
                }

-                info = node.Value.GetInfo();
+                info = currBlock.GetInfo();
            }

            return 0;
--- a/Ryujinx.HLE/HOS/Services/Account/Acc/AccountService/IManagerForApplication.cs
+++ b/Ryujinx.HLE/HOS/Services/Account/Acc/AccountService/IManagerForApplication.cs
@@ -57,5 +57,19 @@ namespace Ryujinx.HLE.HOS.Services.Account.Acc.AccountService
        {
            return _managerServer.StoreOpenContext(context);
        }
+
+        [CommandHipc(170)] // 6.0.0+
+        // LoadNetworkServiceLicenseKindAsync() -> object<nn::account::detail::IAsyncNetworkServiceLicenseKindContext>
+        public ResultCode LoadNetworkServiceLicenseKindAsync(ServiceCtx context)
+        {
+            ResultCode resultCode = _managerServer.LoadNetworkServiceLicenseKindAsync(context, out IAsyncNetworkServiceLicenseKindContext asyncContext);
+
+            if (resultCode == ResultCode.Success)
+            {
+                MakeObject(context, asyncContext);
+            }
+
+            return resultCode;
+        }
    }
 }
--- a/Ryujinx.HLE/HOS/Services/Account/Acc/AccountService/ManagerServer.cs
+++ b/Ryujinx.HLE/HOS/Services/Account/Acc/AccountService/ManagerServer.cs
@@ -166,5 +166,22 @@ namespace Ryujinx.HLE.HOS.Services.Account.Acc.AccountService

            return ResultCode.Success;
        }
+
+        public ResultCode LoadNetworkServiceLicenseKindAsync(ServiceCtx context, out IAsyncNetworkServiceLicenseKindContext asyncContext)
+        {
+            KEvent asyncEvent = new KEvent(context.Device.System.KernelContext);
+            AsyncExecution asyncExecution = new AsyncExecution(asyncEvent);
+
+            Logger.Stub?.PrintStub(LogClass.ServiceAcc);
+
+            // NOTE: This is an extension of the data retrieved from the id token cache.
+            asyncExecution.Initialize(1000, EnsureIdTokenCacheAsyncImpl);
+
+            asyncContext = new IAsyncNetworkServiceLicenseKindContext(asyncExecution, NetworkServiceLicenseKind.Subscribed);
+
+            // return ResultCode.NullObject if the IAsyncNetworkServiceLicenseKindContext pointer is null. Doesn't occur in our case.
+
+            return ResultCode.Success;
+        }
    }
 }
--- a/Ryujinx.HLE/HOS/Services/Account/Acc/IAsyncContext.cs
+++ b/Ryujinx.HLE/HOS/Services/Account/Acc/IAsyncContext.cs
@@ -7,18 +7,18 @@ namespace Ryujinx.HLE.HOS.Services.Account.Acc
 {
    class IAsyncContext : IpcService
    {
-        AsyncExecution _asyncExecution;
+        protected AsyncExecution AsyncExecution;

        public IAsyncContext(AsyncExecution asyncExecution)
        {
-            _asyncExecution = asyncExecution;
+            AsyncExecution = asyncExecution;
        }

        [CommandHipc(0)]
        // GetSystemEvent() -> handle<copy>
        public ResultCode GetSystemEvent(ServiceCtx context)
        {
-            if (context.Process.HandleTable.GenerateHandle(_asyncExecution.SystemEvent.ReadableEvent, out int _systemEventHandle) != KernelResult.Success)
+            if (context.Process.HandleTable.GenerateHandle(AsyncExecution.SystemEvent.ReadableEvent, out int _systemEventHandle) != KernelResult.Success)
            {
                throw new InvalidOperationException("Out of handles!");
            }
@@ -32,14 +32,14 @@ namespace Ryujinx.HLE.HOS.Services.Account.Acc
        // Cancel()
        public ResultCode Cancel(ServiceCtx context)
        {
-            if (!_asyncExecution.IsInitialized)
+            if (!AsyncExecution.IsInitialized)
            {
                return ResultCode.AsyncExecutionNotInitialized;
            }

-            if (_asyncExecution.IsRunning)
+            if (AsyncExecution.IsRunning)
            {
-                _asyncExecution.Cancel();
+                AsyncExecution.Cancel();
            }

            return ResultCode.Success;
@@ -49,12 +49,12 @@ namespace Ryujinx.HLE.HOS.Services.Account.Acc
        // HasDone() -> b8
        public ResultCode HasDone(ServiceCtx context)
        {
-            if (!_asyncExecution.IsInitialized)
+            if (!AsyncExecution.IsInitialized)
            {
                return ResultCode.AsyncExecutionNotInitialized;
            }

-            context.ResponseData.Write(_asyncExecution.SystemEvent.ReadableEvent.IsSignaled());
+            context.ResponseData.Write(AsyncExecution.SystemEvent.ReadableEvent.IsSignaled());

            return ResultCode.Success;
        }
@@ -63,12 +63,12 @@ namespace Ryujinx.HLE.HOS.Services.Account.Acc
        // GetResult()
        public ResultCode GetResult(ServiceCtx context)
        {
-            if (!_asyncExecution.IsInitialized)
+            if (!AsyncExecution.IsInitialized)
            {
                return ResultCode.AsyncExecutionNotInitialized;
            }

-            if (!_asyncExecution.SystemEvent.ReadableEvent.IsSignaled())
+            if (!AsyncExecution.SystemEvent.ReadableEvent.IsSignaled())
            {
                return ResultCode.Unknown41;
            }
--- a/Ryujinx.HLE/HOS/Services/Account/Acc/IAsyncNetworkServiceLicenseKindContext.cs
+++ b/Ryujinx.HLE/HOS/Services/Account/Acc/IAsyncNetworkServiceLicenseKindContext.cs
@@ -0,0 +1,38 @@
+using Ryujinx.HLE.HOS.Services.Account.Acc.AsyncContext;
+
+namespace Ryujinx.HLE.HOS.Services.Account.Acc
+{
+    class IAsyncNetworkServiceLicenseKindContext : IAsyncContext
+    {
+        private NetworkServiceLicenseKind? _serviceLicenseKind;
+
+        public IAsyncNetworkServiceLicenseKindContext(AsyncExecution asyncExecution, NetworkServiceLicenseKind? serviceLicenseKind) : base(asyncExecution)
+        {
+            _serviceLicenseKind = serviceLicenseKind;
+        }
+
+        [CommandHipc(100)]
+        // GetNetworkServiceLicenseKind() -> nn::account::NetworkServiceLicenseKind
+        public ResultCode GetNetworkServiceLicenseKind(ServiceCtx context)
+        {
+            if (!AsyncExecution.IsInitialized)
+            {
+                return ResultCode.AsyncExecutionNotInitialized;
+            }
+
+            if (!AsyncExecution.SystemEvent.ReadableEvent.IsSignaled())
+            {
+                return ResultCode.Unknown41;
+            }
+
+            if (!_serviceLicenseKind.HasValue)
+            {
+                return ResultCode.MissingNetworkServiceLicenseKind;
+            }
+
+            context.ResponseData.Write((uint)_serviceLicenseKind.Value);
+
+            return ResultCode.Success;
+        }
+    }
+}
--- a/Ryujinx.HLE/HOS/Services/Account/Acc/Types/NetworkServiceLicenseKind.cs
+++ b/Ryujinx.HLE/HOS/Services/Account/Acc/Types/NetworkServiceLicenseKind.cs
@@ -0,0 +1,8 @@
+namespace Ryujinx.HLE.HOS.Services.Account.Acc
+{
+    enum NetworkServiceLicenseKind : uint
+    {
+        NoSubscription,
+        Subscribed
+    }
+}
--- a/Ryujinx.HLE/HOS/Services/Account/ResultCode.cs
+++ b/Ryujinx.HLE/HOS/Services/Account/ResultCode.cs
@@ -7,17 +7,18 @@ namespace Ryujinx.HLE.HOS.Services.Account

        Success = 0,

-        NullArgument                  = (20  << ErrorCodeShift) | ModuleId,
-        InvalidArgument               = (22  << ErrorCodeShift) | ModuleId,
-        NullInputBuffer               = (30  << ErrorCodeShift) | ModuleId,
-        InvalidBufferSize             = (31  << ErrorCodeShift) | ModuleId,
-        InvalidBuffer                 = (32  << ErrorCodeShift) | ModuleId,
-        AsyncExecutionNotInitialized  = (40  << ErrorCodeShift) | ModuleId,
-        Unknown41                     = (41  << ErrorCodeShift) | ModuleId,
-        InternetRequestDenied         = (59  << ErrorCodeShift) | ModuleId,
-        UserNotFound                  = (100 << ErrorCodeShift) | ModuleId,
-        NullObject                    = (302 << ErrorCodeShift) | ModuleId,
-        Unknown341                    = (341 << ErrorCodeShift) | ModuleId,
-        InvalidIdTokenCacheBufferSize = (451 << ErrorCodeShift) | ModuleId
+        NullArgument                     = (20  << ErrorCodeShift) | ModuleId,
+        InvalidArgument                  = (22  << ErrorCodeShift) | ModuleId,
+        NullInputBuffer                  = (30  << ErrorCodeShift) | ModuleId,
+        InvalidBufferSize                = (31  << ErrorCodeShift) | ModuleId,
+        InvalidBuffer                    = (32  << ErrorCodeShift) | ModuleId,
+        AsyncExecutionNotInitialized     = (40  << ErrorCodeShift) | ModuleId,
+        Unknown41                        = (41  << ErrorCodeShift) | ModuleId,
+        InternetRequestDenied            = (59  << ErrorCodeShift) | ModuleId,
+        UserNotFound                     = (100 << ErrorCodeShift) | ModuleId,
+        NullObject                       = (302 << ErrorCodeShift) | ModuleId,
+        Unknown341                       = (341 << ErrorCodeShift) | ModuleId,
+        MissingNetworkServiceLicenseKind = (400 << ErrorCodeShift) | ModuleId,
+        InvalidIdTokenCacheBufferSize    = (451 << ErrorCodeShift) | ModuleId
    }
 }
--- a/Ryujinx.HLE/HOS/Services/Sockets/Bsd/IClient.cs
+++ b/Ryujinx.HLE/HOS/Services/Sockets/Bsd/IClient.cs
@@ -336,6 +336,12 @@ namespace Ryujinx.HLE.HOS.Services.Sockets.Bsd
                context.Memory.Write(outputBufferPosition + (ulong)(i * Unsafe.SizeOf<PollEventData>()), events[i].Data);
            }

+            // In case of non blocking call timeout should not be returned.
+            if (timeout == 0 && errno == LinuxError.ETIMEDOUT)
+            {
+                errno = LinuxError.SUCCESS;
+            }
+
            return WriteBsdResult(context, updateCount, errno);
        }

--- a/Ryujinx.HLE/HOS/Services/Sockets/Bsd/Impl/ManagedSocket.cs
+++ b/Ryujinx.HLE/HOS/Services/Sockets/Bsd/Impl/ManagedSocket.cs
@@ -323,9 +323,14 @@ namespace Ryujinx.HLE.HOS.Services.Sockets.Bsd

                int value = optionValue.Length >= 4 ? MemoryMarshal.Read<int>(optionValue) : MemoryMarshal.Read<byte>(optionValue);

-                if (option == BsdSocketOption.SoLinger)
+                if (level == SocketOptionLevel.Socket && option == BsdSocketOption.SoLinger)
                {
-                    int value2 = MemoryMarshal.Read<int>(optionValue[4..]);
+                    int value2 = 0;
+
+                    if (optionValue.Length >= 8)
+                    {
+                        value2 = MemoryMarshal.Read<int>(optionValue[4..]);
+                    }

                    Socket.SetSocketOption(level, SocketOptionName.Linger, new LingerOption(value != 0, value2));
                }
--- a/Ryujinx.HLE/HOS/Services/Sockets/Sfdnsres/Types/AddrInfo4.cs
+++ b/Ryujinx.HLE/HOS/Services/Sockets/Sfdnsres/Types/AddrInfo4.cs
@@ -19,7 +19,7 @@ namespace Ryujinx.HLE.HOS.Services.Sockets.Sfdnsres.Types
        {
            Length  = (byte)Unsafe.SizeOf<Array4<byte>>();
            Family  = (byte)AddressFamily.InterNetwork;
-            Port    = port;
+            Port    = IPAddress.HostToNetworkOrder(port);
            Address = new Array4<byte>();

            address.TryWriteBytes(Address.AsSpan(), out _);
--- a/Ryujinx.Memory/WindowsShared/IntervalTree.cs
+++ b/Ryujinx.Memory/WindowsShared/IntervalTree.cs
@@ -1,3 +1,4 @@
+using Ryujinx.Common.Collections;
 using System;
 using System.Collections.Generic;

@@ -8,19 +9,10 @@ namespace Ryujinx.Memory.WindowsShared
    /// </summary>
    /// <typeparam name="K">Key</typeparam>
    /// <typeparam name="V">Value</typeparam>
-    class IntervalTree<K, V> where K : IComparable<K>
+    class IntervalTree<K, V> : IntrusiveRedBlackTreeImpl<IntervalTreeNode<K, V>> where K : IComparable<K>
    {
        private const int ArrayGrowthSize = 32;

-        private const bool Black = true;
-        private const bool Red = false;
-        private IntervalTreeNode<K, V> _root = null;
-        private int _count = 0;
-
-        public int Count => _count;
-
-        public IntervalTree() { }
-
        #region Public Methods

        /// <summary>
@@ -53,7 +45,7 @@ namespace Ryujinx.Memory.WindowsShared
        /// <returns>Number of intervals found</returns>
        public int Get(K start, K end, ref IntervalTreeNode<K, V>[] overlaps, int overlapCount = 0)
        {
-            GetNodes(_root, start, end, ref overlaps, ref overlapCount);
+            GetNodes(Root, start, end, ref overlaps, ref overlapCount);

            return overlapCount;
        }
@@ -99,7 +91,7 @@ namespace Ryujinx.Memory.WindowsShared

            Delete(nodeToDelete);

-            _count--;
+            Count--;

            return 1;
        }
@@ -112,7 +104,7 @@ namespace Ryujinx.Memory.WindowsShared
        {
            List<V> list = new List<V>();

-            AddToList(_root, list);
+            AddToList(Root, list);

            return list;
        }
@@ -153,7 +145,7 @@ namespace Ryujinx.Memory.WindowsShared
                throw new ArgumentNullException(nameof(key));
            }

-            IntervalTreeNode<K, V> node = _root;
+            IntervalTreeNode<K, V> node = Root;
            while (node != null)
            {
                int cmp = key.CompareTo(node.Start);
@@ -271,7 +263,7 @@ namespace Ryujinx.Memory.WindowsShared
        private bool BSTInsert(K start, K end, V value, Func<K, V, V> updateFactoryCallback, out IntervalTreeNode<K, V> outNode)
        {
            IntervalTreeNode<K, V> parent = null;
-            IntervalTreeNode<K, V> node = _root;
+            IntervalTreeNode<K, V> node = Root;

            while (node != null)
            {
@@ -319,7 +311,7 @@ namespace Ryujinx.Memory.WindowsShared
            IntervalTreeNode<K, V> newNode = new IntervalTreeNode<K, V>(start, end, value, parent);
            if (newNode.Parent == null)
            {
-                _root = newNode;
+                Root = newNode;
            }
            else if (start.CompareTo(parent.Start) < 0)
            {
@@ -331,7 +323,7 @@ namespace Ryujinx.Memory.WindowsShared
            }

            PropagateIncrease(newNode);
-            _count++;
+            Count++;
            RestoreBalanceAfterInsertion(newNode);
            outNode = newNode;
            return true;
@@ -351,7 +343,7 @@ namespace Ryujinx.Memory.WindowsShared
            }
            else
            {
-                replacementNode = PredecessorOf(nodeToDelete);
+                replacementNode = nodeToDelete.Predecessor;
            }

            IntervalTreeNode<K, V> tmp = LeftOf(replacementNode) ?? RightOf(replacementNode);
@@ -363,7 +355,7 @@ namespace Ryujinx.Memory.WindowsShared

            if (ParentOf(replacementNode) == null)
            {
-                _root = tmp;
+                Root = tmp;
            }
            else if (replacementNode == LeftOf(ParentOf(replacementNode)))
            {
@@ -390,232 +382,25 @@ namespace Ryujinx.Memory.WindowsShared
            }
        }

-        /// <summary>
-        /// Returns the node with the largest key where <paramref name="node"/> is considered the root node.
-        /// </summary>
-        /// <param name="node">Root Node</param>
-        /// <returns>Node with the maximum key in the tree of <paramref name="node"/></returns>
-        private static IntervalTreeNode<K, V> Maximum(IntervalTreeNode<K, V> node)
-        {
-            IntervalTreeNode<K, V> tmp = node;
-            while (tmp.Right != null)
-            {
-                tmp = tmp.Right;
-            }
-
-            return tmp;
-        }
-
-        /// <summary>
-        /// Finds the node whose key is immediately less than <paramref name="node"/>.
-        /// </summary>
-        /// <param name="node">Node to find the predecessor of</param>
-        /// <returns>Predecessor of <paramref name="node"/></returns>
-        private static IntervalTreeNode<K, V> PredecessorOf(IntervalTreeNode<K, V> node)
-        {
-            if (node.Left != null)
-            {
-                return Maximum(node.Left);
-            }
-            IntervalTreeNode<K, V> parent = node.Parent;
-            while (parent != null && node == parent.Left)
-            {
-                node = parent;
-                parent = parent.Parent;
-            }
-            return parent;
-        }
-
        #endregion

        #region Private Methods (RBL)

-        private void RestoreBalanceAfterRemoval(IntervalTreeNode<K, V> balanceNode)
-        {
-            IntervalTreeNode<K, V> ptr = balanceNode;
-
-            while (ptr != _root && ColorOf(ptr) == Black)
-            {
-                if (ptr == LeftOf(ParentOf(ptr)))
-                {
-                    IntervalTreeNode<K, V> sibling = RightOf(ParentOf(ptr));
-
-                    if (ColorOf(sibling) == Red)
-                    {
-                        SetColor(sibling, Black);
-                        SetColor(ParentOf(ptr), Red);
-                        RotateLeft(ParentOf(ptr));
-                        sibling = RightOf(ParentOf(ptr));
-                    }
-                    if (ColorOf(LeftOf(sibling)) == Black && ColorOf(RightOf(sibling)) == Black)
-                    {
-                        SetColor(sibling, Red);
-                        ptr = ParentOf(ptr);
-                    }
-                    else
-                    {
-                        if (ColorOf(RightOf(sibling)) == Black)
-                        {
-                            SetColor(LeftOf(sibling), Black);
-                            SetColor(sibling, Red);
-                            RotateRight(sibling);
-                            sibling = RightOf(ParentOf(ptr));
-                        }
-                        SetColor(sibling, ColorOf(ParentOf(ptr)));
-                        SetColor(ParentOf(ptr), Black);
-                        SetColor(RightOf(sibling), Black);
-                        RotateLeft(ParentOf(ptr));
-                        ptr = _root;
-                    }
-                }
-                else
-                {
-                    IntervalTreeNode<K, V> sibling = LeftOf(ParentOf(ptr));
-
-                    if (ColorOf(sibling) == Red)
-                    {
-                        SetColor(sibling, Black);
-                        SetColor(ParentOf(ptr), Red);
-                        RotateRight(ParentOf(ptr));
-                        sibling = LeftOf(ParentOf(ptr));
-                    }
-                    if (ColorOf(RightOf(sibling)) == Black && ColorOf(LeftOf(sibling)) == Black)
-                    {
-                        SetColor(sibling, Red);
-                        ptr = ParentOf(ptr);
-                    }
-                    else
-                    {
-                        if (ColorOf(LeftOf(sibling)) == Black)
-                        {
-                            SetColor(RightOf(sibling), Black);
-                            SetColor(sibling, Red);
-                            RotateLeft(sibling);
-                            sibling = LeftOf(ParentOf(ptr));
-                        }
-                        SetColor(sibling, ColorOf(ParentOf(ptr)));
-                        SetColor(ParentOf(ptr), Black);
-                        SetColor(LeftOf(sibling), Black);
-                        RotateRight(ParentOf(ptr));
-                        ptr = _root;
-                    }
-                }
-            }
-            SetColor(ptr, Black);
-        }
-
-        private void RestoreBalanceAfterInsertion(IntervalTreeNode<K, V> balanceNode)
-        {
-            SetColor(balanceNode, Red);
-            while (balanceNode != null && balanceNode != _root && ColorOf(ParentOf(balanceNode)) == Red)
-            {
-                if (ParentOf(balanceNode) == LeftOf(ParentOf(ParentOf(balanceNode))))
-                {
-                    IntervalTreeNode<K, V> sibling = RightOf(ParentOf(ParentOf(balanceNode)));
-
-                    if (ColorOf(sibling) == Red)
-                    {
-                        SetColor(ParentOf(balanceNode), Black);
-                        SetColor(sibling, Black);
-                        SetColor(ParentOf(ParentOf(balanceNode)), Red);
-                        balanceNode = ParentOf(ParentOf(balanceNode));
-                    }
-                    else
-                    {
-                        if (balanceNode == RightOf(ParentOf(balanceNode)))
-                        {
-                            balanceNode = ParentOf(balanceNode);
-                            RotateLeft(balanceNode);
-                        }
-                        SetColor(ParentOf(balanceNode), Black);
-                        SetColor(ParentOf(ParentOf(balanceNode)), Red);
-                        RotateRight(ParentOf(ParentOf(balanceNode)));
-                    }
-                }
-                else
-                {
-                    IntervalTreeNode<K, V> sibling = LeftOf(ParentOf(ParentOf(balanceNode)));
-
-                    if (ColorOf(sibling) == Red)
-                    {
-                        SetColor(ParentOf(balanceNode), Black);
-                        SetColor(sibling, Black);
-                        SetColor(ParentOf(ParentOf(balanceNode)), Red);
-                        balanceNode = ParentOf(ParentOf(balanceNode));
-                    }
-                    else
-                    {
-                        if (balanceNode == LeftOf(ParentOf(balanceNode)))
-                        {
-                            balanceNode = ParentOf(balanceNode);
-                            RotateRight(balanceNode);
-                        }
-                        SetColor(ParentOf(balanceNode), Black);
-                        SetColor(ParentOf(ParentOf(balanceNode)), Red);
-                        RotateLeft(ParentOf(ParentOf(balanceNode)));
-                    }
-                }
-            }
-            SetColor(_root, Black);
-        }
-
-        private void RotateLeft(IntervalTreeNode<K, V> node)
+        protected override void RotateLeft(IntervalTreeNode<K, V> node)
        {
            if (node != null)
            {
-                IntervalTreeNode<K, V> right = RightOf(node);
-                node.Right = LeftOf(right);
-                if (node.Right != null)
-                {
-                    node.Right.Parent = node;
-                }
-                IntervalTreeNode<K, V> nodeParent = ParentOf(node);
-                right.Parent = nodeParent;
-                if (nodeParent == null)
-                {
-                    _root = right;
-                }
-                else if (node == LeftOf(nodeParent))
-                {
-                    nodeParent.Left = right;
-                }
-                else
-                {
-                    nodeParent.Right = right;
-                }
-                right.Left = node;
-                node.Parent = right;
+                base.RotateLeft(node);

                PropagateFull(node);
            }
        }

-        private void RotateRight(IntervalTreeNode<K, V> node)
+        protected override void RotateRight(IntervalTreeNode<K, V> node)
        {
            if (node != null)
            {
-                IntervalTreeNode<K, V> left = LeftOf(node);
-                node.Left = RightOf(left);
-                if (node.Left != null)
-                {
-                    node.Left.Parent = node;
-                }
-                IntervalTreeNode<K, V> nodeParent = ParentOf(node);
-                left.Parent = nodeParent;
-                if (nodeParent == null)
-                {
-                    _root = left;
-                }
-                else if (node == RightOf(nodeParent))
-                {
-                    nodeParent.Right = left;
-                }
-                else
-                {
-                    nodeParent.Left = left;
-                }
-                left.Right = node;
-                node.Parent = left;
+                base.RotateRight(node);

                PropagateFull(node);
            }
@@ -623,77 +408,10 @@ namespace Ryujinx.Memory.WindowsShared

        #endregion

-        #region Safety-Methods
-
-        // These methods save memory by allowing us to forego sentinel nil nodes, as well as serve as protection against NullReferenceExceptions.
-
-        /// <summary>
-        /// Returns the color of <paramref name="node"/>, or Black if it is null.
-        /// </summary>
-        /// <param name="node">Node</param>
-        /// <returns>The boolean color of <paramref name="node"/>, or black if null</returns>
-        private static bool ColorOf(IntervalTreeNode<K, V> node)
-        {
-            return node == null || node.Color;
-        }
-
-        /// <summary>
-        /// Sets the color of <paramref name="node"/> node to <paramref name="color"/>.
-        /// <br></br>
-        /// This method does nothing if <paramref name="node"/> is null.
-        /// </summary>
-        /// <param name="node">Node to set the color of</param>
-        /// <param name="color">Color (Boolean)</param>
-        private static void SetColor(IntervalTreeNode<K, V> node, bool color)
-        {
-            if (node != null)
-            {
-                node.Color = color;
-            }
-        }
-
-        /// <summary>
-        /// This method returns the left node of <paramref name="node"/>, or null if <paramref name="node"/> is null.
-        /// </summary>
-        /// <param name="node">Node to retrieve the left child from</param>
-        /// <returns>Left child of <paramref name="node"/></returns>
-        private static IntervalTreeNode<K, V> LeftOf(IntervalTreeNode<K, V> node)
-        {
-            return node?.Left;
-        }
-
-        /// <summary>
-        /// This method returns the right node of <paramref name="node"/>, or null if <paramref name="node"/> is null.
-        /// </summary>
-        /// <param name="node">Node to retrieve the right child from</param>
-        /// <returns>Right child of <paramref name="node"/></returns>
-        private static IntervalTreeNode<K, V> RightOf(IntervalTreeNode<K, V> node)
-        {
-            return node?.Right;
-        }
-
-        /// <summary>
-        /// Returns the parent node of <paramref name="node"/>, or null if <paramref name="node"/> is null.
-        /// </summary>
-        /// <param name="node">Node to retrieve the parent from</param>
-        /// <returns>Parent of <paramref name="node"/></returns>
-        private static IntervalTreeNode<K, V> ParentOf(IntervalTreeNode<K, V> node)
-        {
-            return node?.Parent;
-        }
-
-        #endregion
-
        public bool ContainsKey(K key)
        {
            return GetNode(key) != null;
        }
-
-        public void Clear()
-        {
-            _root = null;
-            _count = 0;
-        }
    }

    /// <summary>
@@ -701,13 +419,8 @@ namespace Ryujinx.Memory.WindowsShared
    /// </summary>
    /// <typeparam name="K">Key type of the node</typeparam>
    /// <typeparam name="V">Value type of the node</typeparam>
-    class IntervalTreeNode<K, V>
+    class IntervalTreeNode<K, V> : IntrusiveRedBlackTreeNode<IntervalTreeNode<K, V>>
    {
-        public bool Color = true;
-        public IntervalTreeNode<K, V> Left = null;
-        public IntervalTreeNode<K, V> Right = null;
-        public IntervalTreeNode<K, V> Parent = null;
-
        /// <summary>
        /// The start of the range.
        /// </summary>
Author	SHA1	Message	Date
Mary	67cbdc3a6a	bsd: Fix Poll(0) returning ETIMEDOUT instead of SUCCESS This was an oversight of the implementation.	2022-09-01 21:46:11 +02:00
Mary	131b43170e	sfdsnres: fix endianess issue for port serialisation	2022-09-01 21:31:20 +02:00
Mary	730d2f4b9b	Address gdkchan's comment	2022-08-31 21:33:03 +02:00
Mary	f6a7309b14	account: Implement LoadNetworkServiceLicenseKindAsync This is needed to run Pokemon Legends Arceus 1.1.1 with guest internet enabled. The game still get stuck at loading screen.	2022-08-31 21:33:03 +02:00
TSRBerry	472a621589	Bsd: Fix ArgumentOutOfRangeException in SetSocketOption (#3633 ) * Bsd: Fix ArgumentOutOfRangeException in SetSocketOption * Ensure option level is Socket before checking for SoLinger	2022-08-28 14:24:19 +00:00
mageven	311c2661b8	Replace image format magic numbers with enums (#3631 ) * Replace magic constants with enums * Extra formatting * Lower case ASTC dimensions * Use uint for VertexAttributeFormat	2022-08-28 01:56:26 +00:00
txorion	a92e2028cb	Updates Japanese localization for the Avalonia UI (#3635 )	2022-08-27 07:01:30 +00:00
gdkchan	6922862db8	Optimize kernel memory block lookup and consolidate RBTree implementations (#3410 ) * Implement intrusive red-black tree, use it for HLE kernel block manager * Implement TreeDictionary using IntrusiveRedBlackTree * Implement IntervalTree using IntrusiveRedBlackTree * Implement IntervalTree (on Ryujinx.Memory) using IntrusiveRedBlackTree * Make PredecessorOf and SuccessorOf internal, expose Predecessor and Successor properties on the node itself * Allocation free tree node lookup	2022-08-26 18:21:48 +00:00