1 files changed, 103 insertions, 11 deletions
diff --git a/Ryujinx.Graphics.Vulkan/CacheByRange.cs b/Ryujinx.Graphics.Vulkan/CacheByRange.cs
index f3f503da..f9edca8a 100644
--- a/Ryujinx.Graphics.Vulkan/CacheByRange.cs
+++ b/Ryujinx.Graphics.Vulkan/CacheByRange.cs
@@ -3,29 +3,110 @@ using System.Collections.Generic;
 
 namespace Ryujinx.Graphics.Vulkan
 {
+    interface ICacheKey : IDisposable
+    {
+        bool KeyEqual(ICacheKey other);
+    }
+
+    struct I8ToI16CacheKey : ICacheKey
+    {
+        public I8ToI16CacheKey() { }
+
+        public bool KeyEqual(ICacheKey other)
+        {
+            return other is I8ToI16CacheKey;
+        }
+
+        public void Dispose() { }
+    }
+
+    struct AlignedVertexBufferCacheKey : ICacheKey
+    {
+        private readonly int _stride;
+        private readonly int _alignment;
+
+        // Used to notify the pipeline that bindings have invalidated on dispose.
+        private readonly VulkanRenderer _gd;
+        private Auto<DisposableBuffer> _buffer;
+
+        public AlignedVertexBufferCacheKey(VulkanRenderer gd, int stride, int alignment)
+        {
+            _gd = gd;
+            _stride = stride;
+            _alignment = alignment;
+            _buffer = null;
+        }
+
+        public bool KeyEqual(ICacheKey other)
+        {
+            return other is AlignedVertexBufferCacheKey entry &&
+                entry._stride == _stride &&
+                entry._alignment == _alignment;
+        }
+
+        public void SetBuffer(Auto<DisposableBuffer> buffer)
+        {
+            _buffer = buffer;
+        }
+
+        public void Dispose()
+        {
+            _gd.PipelineInternal.DirtyVertexBuffer(_buffer);
+        }
+    }
+
     struct CacheByRange<T> where T : IDisposable
     {
-        private Dictionary<ulong, T> _ranges;
+        private struct Entry
+        {
+            public ICacheKey Key;
+            public T Value;
+
+            public Entry(ICacheKey key, T value)
+            {
+                Key = key;
+                Value = value;
+            }
+        }
 
-        public void Add(int offset, int size, T value)
+        private Dictionary<ulong, List<Entry>> _ranges;
+
+        public void Add(int offset, int size, ICacheKey key, T value)
         {
-            EnsureInitialized();
-            _ranges.Add(PackRange(offset, size),  value);
+            List<Entry> entries = GetEntries(offset, size);
+
+            entries.Add(new Entry(key, value));
         }
 
-        public bool TryGetValue(int offset, int size, out T value)
+        public bool TryGetValue(int offset, int size, ICacheKey key, out T value)
         {
-            EnsureInitialized();
-            return _ranges.TryGetValue(PackRange(offset, size), out value);
+            List<Entry> entries = GetEntries(offset, size);
+
+            foreach (Entry entry in entries)
+            {
+                if (entry.Key.KeyEqual(key))
+                {
+                    value = entry.Value;
+
+                    return true;
+                }
+            }
+
+            value = default;
+            return false;
         }
 
         public void Clear()
         {
             if (_ranges != null)
             {
-                foreach (T value in _ranges.Values)
+                foreach (List<Entry> entries in _ranges.Values)
                 {
-                    value.Dispose();
+                    foreach (Entry entry in entries)
+                    {
+                        entry.Key.Dispose();
+                        entry.Value.Dispose();
+                    }
                 }
 
                 _ranges.Clear();
@@ -33,12 +114,23 @@ namespace Ryujinx.Graphics.Vulkan
             }
         }
 
-        private void EnsureInitialized()
+        private List<Entry> GetEntries(int offset, int size)
         {
             if (_ranges == null)
             {
-                _ranges = new Dictionary<ulong, T>();
+                _ranges = new Dictionary<ulong, List<Entry>>();
             }
+
+            ulong key = PackRange(offset, size);
+
+            List<Entry> value;
+            if (!_ranges.TryGetValue(key, out value))
+            {
+                value = new List<Entry>();
+                _ranges.Add(key, value);
+            }
+
+            return value;
         }
 
         private static ulong PackRange(int offset, int size)