renderer_vulkan: Commize and adjust buffer bindings (#1412)

* shader_recompiler: Implement finite cmp class

* shader_recompiler: Implement more opcodes

* renderer_vulkan: Commonize buffer binding

* liverpool: More dma data impl

* fix

* copy_shader: Handle additional instructions from Knack

* translator: Add V_CMPX_GE_I32

src/video_core/renderer_vulkan/vk_compute_pipeline.cpp

@@ -3,7 +3,6 @@
 
 #include <boost/container/small_vector.hpp>
 
-#include "common/alignment.h"
 #include "video_core/buffer_cache/buffer_cache.h"
 #include "video_core/renderer_vulkan/vk_compute_pipeline.h"
 #include "video_core/renderer_vulkan/vk_instance.h"
@@ -113,140 +112,45 @@ ComputePipeline::~ComputePipeline() = default;
 bool ComputePipeline::BindResources(VideoCore::BufferCache& buffer_cache,
                                     VideoCore::TextureCache& texture_cache) const {
     // Bind resource buffers and textures.
-    boost::container::static_vector<vk::BufferView, 8> buffer_views;
-    boost::container::static_vector<vk::DescriptorBufferInfo, 32> buffer_infos;
     boost::container::small_vector<vk::WriteDescriptorSet, 16> set_writes;
-    boost::container::small_vector<vk::BufferMemoryBarrier2, 16> buffer_barriers;
+    BufferBarriers buffer_barriers;
     Shader::PushData push_data{};
     Shader::Backend::Bindings binding{};
 
+    info->PushUd(binding, push_data);
+
+    buffer_infos.clear();
+    buffer_views.clear();
     image_infos.clear();
 
-    info->PushUd(binding, push_data);
-    for (const auto& desc : info->buffers) {
-        bool is_storage = true;
-        if (desc.is_gds_buffer) {
-            auto* vk_buffer = buffer_cache.GetGdsBuffer();
-            buffer_infos.emplace_back(vk_buffer->Handle(), 0, vk_buffer->SizeBytes());
-        } else {
-            const auto vsharp = desc.GetSharp(*info);
-            is_storage = desc.IsStorage(vsharp);
-            const VAddr address = vsharp.base_address;
-            // Most of the time when a metadata is updated with a shader it gets cleared. It means
-            // we can skip the whole dispatch and update the tracked state instead. Also, it is not
-            // intended to be consumed and in such rare cases (e.g. HTile introspection, CRAA) we
-            // will need its full emulation anyways. For cases of metadata read a warning will be
-            // logged.
-            if (desc.is_written) {
-                if (texture_cache.TouchMeta(address, true)) {
-                    LOG_TRACE(Render_Vulkan, "Metadata update skipped");
-                    return false;
-                }
-            } else {
-                if (texture_cache.IsMeta(address)) {
-                    LOG_WARNING(Render_Vulkan, "Unexpected metadata read by a CS shader (buffer)");
-                }
+    // Most of the time when a metadata is updated with a shader it gets cleared. It means
+    // we can skip the whole dispatch and update the tracked state instead. Also, it is not
+    // intended to be consumed and in such rare cases (e.g. HTile introspection, CRAA) we
+    // will need its full emulation anyways. For cases of metadata read a warning will be logged.
+    for (const auto& desc : info->texture_buffers) {
+        const VAddr address = desc.GetSharp(*info).base_address;
+        if (desc.is_written) {
+            if (texture_cache.TouchMeta(address, true)) {
+                LOG_TRACE(Render_Vulkan, "Metadata update skipped");
+                return false;
+            }
+        } else {
+            if (texture_cache.IsMeta(address)) {
+                LOG_WARNING(Render_Vulkan, "Unexpected metadata read by a CS shader (buffer)");
             }
-            const u32 size = vsharp.GetSize();
-            const u32 alignment =
-                is_storage ? instance.StorageMinAlignment() : instance.UniformMinAlignment();
-            const auto [vk_buffer, offset] =
-                buffer_cache.ObtainBuffer(address, size, desc.is_written);
-            const u32 offset_aligned = Common::AlignDown(offset, alignment);
-            const u32 adjust = offset - offset_aligned;
-            ASSERT(adjust % 4 == 0);
-            push_data.AddOffset(binding.buffer, adjust);
-            buffer_infos.emplace_back(vk_buffer->Handle(), offset_aligned, size + adjust);
         }
-        set_writes.push_back({
-            .dstSet = VK_NULL_HANDLE,
-            .dstBinding = binding.unified++,
-            .dstArrayElement = 0,
-            .descriptorCount = 1,
-            .descriptorType = is_storage ? vk::DescriptorType::eStorageBuffer
-                                         : vk::DescriptorType::eUniformBuffer,
-            .pBufferInfo = &buffer_infos.back(),
-        });
-        ++binding.buffer;
     }
 
-    const auto null_buffer_view =
-        instance.IsNullDescriptorSupported() ? VK_NULL_HANDLE : buffer_cache.NullBufferView();
-    for (const auto& desc : info->texture_buffers) {
-        const auto vsharp = desc.GetSharp(*info);
-        vk::BufferView& buffer_view = buffer_views.emplace_back(null_buffer_view);
-        const u32 size = vsharp.GetSize();
-        if (vsharp.GetDataFmt() != AmdGpu::DataFormat::FormatInvalid && size != 0) {
-            const VAddr address = vsharp.base_address;
-            if (desc.is_written) {
-                if (texture_cache.TouchMeta(address, true)) {
-                    LOG_TRACE(Render_Vulkan, "Metadata update skipped");
-                    return false;
-                }
-            } else {
-                if (texture_cache.IsMeta(address)) {
-                    LOG_WARNING(Render_Vulkan, "Unexpected metadata read by a CS shader (buffer)");
-                }
-            }
-            const u32 alignment = instance.TexelBufferMinAlignment();
-            const auto [vk_buffer, offset] =
-                buffer_cache.ObtainBuffer(address, size, desc.is_written, true);
-            const u32 fmt_stride = AmdGpu::NumBits(vsharp.GetDataFmt()) >> 3;
-            ASSERT_MSG(fmt_stride == vsharp.GetStride(),
-                       "Texel buffer stride must match format stride");
-            const u32 offset_aligned = Common::AlignDown(offset, alignment);
-            const u32 adjust = offset - offset_aligned;
-            ASSERT(adjust % fmt_stride == 0);
-            push_data.AddOffset(binding.buffer, adjust / fmt_stride);
-            buffer_view = vk_buffer->View(offset_aligned, size + adjust, desc.is_written,
-                                          vsharp.GetDataFmt(), vsharp.GetNumberFmt());
-            if (auto barrier =
-                    vk_buffer->GetBarrier(desc.is_written ? vk::AccessFlagBits2::eShaderWrite
-                                                          : vk::AccessFlagBits2::eShaderRead,
-                                          vk::PipelineStageFlagBits2::eComputeShader)) {
-                buffer_barriers.emplace_back(*barrier);
-            }
-            if (desc.is_written) {
-                texture_cache.InvalidateMemoryFromGPU(address, size);
-            }
-        }
-        set_writes.push_back({
-            .dstSet = VK_NULL_HANDLE,
-            .dstBinding = binding.unified++,
-            .dstArrayElement = 0,
-            .descriptorCount = 1,
-            .descriptorType = desc.is_written ? vk::DescriptorType::eStorageTexelBuffer
-                                              : vk::DescriptorType::eUniformTexelBuffer,
-            .pTexelBufferView = &buffer_view,
-        });
-        ++binding.buffer;
-    }
+    BindBuffers(buffer_cache, texture_cache, *info, binding, push_data, set_writes,
+                buffer_barriers);
 
     BindTextures(texture_cache, *info, binding, set_writes);
 
-    for (const auto& sampler : info->samplers) {
-        const auto ssharp = sampler.GetSharp(*info);
-        if (ssharp.force_degamma) {
-            LOG_WARNING(Render_Vulkan, "Texture requires gamma correction");
-        }
-        const auto vk_sampler = texture_cache.GetSampler(ssharp);
-        image_infos.emplace_back(vk_sampler, VK_NULL_HANDLE, vk::ImageLayout::eGeneral);
-        set_writes.push_back({
-            .dstSet = VK_NULL_HANDLE,
-            .dstBinding = binding.unified++,
-            .dstArrayElement = 0,
-            .descriptorCount = 1,
-            .descriptorType = vk::DescriptorType::eSampler,
-            .pImageInfo = &image_infos.back(),
-        });
-    }
-
     if (set_writes.empty()) {
         return false;
     }
 
     const auto cmdbuf = scheduler.CommandBuffer();
-
     if (!buffer_barriers.empty()) {
         const auto dependencies = vk::DependencyInfo{
             .dependencyFlags = vk::DependencyFlagBits::eByRegion,
@@ -257,21 +161,22 @@ bool ComputePipeline::BindResources(VideoCore::BufferCache& buffer_cache,
         cmdbuf.pipelineBarrier2(dependencies);
     }
 
+    cmdbuf.pushConstants(*pipeline_layout, vk::ShaderStageFlagBits::eCompute, 0u, sizeof(push_data),
+                         &push_data);
+
+    // Bind descriptor set.
     if (uses_push_descriptors) {
         cmdbuf.pushDescriptorSetKHR(vk::PipelineBindPoint::eCompute, *pipeline_layout, 0,
                                     set_writes);
-    } else {
-        const auto desc_set = desc_heap.Commit(*desc_layout);
-        for (auto& set_write : set_writes) {
-            set_write.dstSet = desc_set;
-        }
-        instance.GetDevice().updateDescriptorSets(set_writes, {});
-        cmdbuf.bindDescriptorSets(vk::PipelineBindPoint::eCompute, *pipeline_layout, 0, desc_set,
-                                  {});
+        return true;
     }
+    const auto desc_set = desc_heap.Commit(*desc_layout);
+    for (auto& set_write : set_writes) {
+        set_write.dstSet = desc_set;
+    }
+    instance.GetDevice().updateDescriptorSets(set_writes, {});
+    cmdbuf.bindDescriptorSets(vk::PipelineBindPoint::eCompute, *pipeline_layout, 0, desc_set, {});
 
-    cmdbuf.pushConstants(*pipeline_layout, vk::ShaderStageFlagBits::eCompute, 0u, sizeof(push_data),
-                         &push_data);
     return true;
 }
 

src/video_core/renderer_vulkan/vk_graphics_pipeline.cpp

@@ -5,8 +5,8 @@
 #include <boost/container/small_vector.hpp>
 #include <boost/container/static_vector.hpp>
 
-#include "common/alignment.h"
 #include "common/assert.h"
+#include "common/scope_exit.h"
 #include "video_core/amdgpu/resource.h"
 #include "video_core/buffer_cache/buffer_cache.h"
 #include "video_core/renderer_vulkan/vk_graphics_pipeline.h"
@@ -384,13 +384,13 @@ void GraphicsPipeline::BindResources(const Liverpool::Regs& regs,
                                      VideoCore::BufferCache& buffer_cache,
                                      VideoCore::TextureCache& texture_cache) const {
     // Bind resource buffers and textures.
-    boost::container::static_vector<vk::BufferView, 8> buffer_views;
-    boost::container::static_vector<vk::DescriptorBufferInfo, 32> buffer_infos;
     boost::container::small_vector<vk::WriteDescriptorSet, 16> set_writes;
-    boost::container::small_vector<vk::BufferMemoryBarrier2, 16> buffer_barriers;
+    BufferBarriers buffer_barriers;
     Shader::PushData push_data{};
     Shader::Backend::Bindings binding{};
 
+    buffer_infos.clear();
+    buffer_views.clear();
     image_infos.clear();
 
     for (const auto* stage : stages) {
@@ -402,111 +402,22 @@ void GraphicsPipeline::BindResources(const Liverpool::Regs& regs,
             push_data.step1 = regs.vgt_instance_step_rate_1;
         }
         stage->PushUd(binding, push_data);
-        for (const auto& buffer : stage->buffers) {
-            const auto vsharp = buffer.GetSharp(*stage);
-            const bool is_storage = buffer.IsStorage(vsharp);
-            if (vsharp && vsharp.GetSize() > 0) {
-                const VAddr address = vsharp.base_address;
-                if (texture_cache.IsMeta(address)) {
-                    LOG_WARNING(Render_Vulkan, "Unexpected metadata read by a PS shader (buffer)");
-                }
-                const u32 size = vsharp.GetSize();
-                const u32 alignment =
-                    is_storage ? instance.StorageMinAlignment() : instance.UniformMinAlignment();
-                const auto [vk_buffer, offset] =
-                    buffer_cache.ObtainBuffer(address, size, buffer.is_written);
-                const u32 offset_aligned = Common::AlignDown(offset, alignment);
-                const u32 adjust = offset - offset_aligned;
-                ASSERT(adjust % 4 == 0);
-                push_data.AddOffset(binding.buffer, adjust);
-                buffer_infos.emplace_back(vk_buffer->Handle(), offset_aligned, size + adjust);
-            } else if (instance.IsNullDescriptorSupported()) {
-                buffer_infos.emplace_back(VK_NULL_HANDLE, 0, VK_WHOLE_SIZE);
-            } else {
-                auto& null_buffer = buffer_cache.GetBuffer(VideoCore::NULL_BUFFER_ID);
-                buffer_infos.emplace_back(null_buffer.Handle(), 0, VK_WHOLE_SIZE);
-            }
-            set_writes.push_back({
-                .dstSet = VK_NULL_HANDLE,
-                .dstBinding = binding.unified++,
-                .dstArrayElement = 0,
-                .descriptorCount = 1,
-                .descriptorType = is_storage ? vk::DescriptorType::eStorageBuffer
-                                             : vk::DescriptorType::eUniformBuffer,
-                .pBufferInfo = &buffer_infos.back(),
-            });
-            ++binding.buffer;
-        }
 
-        const auto null_buffer_view =
-            instance.IsNullDescriptorSupported() ? VK_NULL_HANDLE : buffer_cache.NullBufferView();
-        for (const auto& desc : stage->texture_buffers) {
-            const auto vsharp = desc.GetSharp(*stage);
-            vk::BufferView& buffer_view = buffer_views.emplace_back(null_buffer_view);
-            const u32 size = vsharp.GetSize();
-            if (vsharp.GetDataFmt() != AmdGpu::DataFormat::FormatInvalid && size != 0) {
-                const VAddr address = vsharp.base_address;
-                const u32 alignment = instance.TexelBufferMinAlignment();
-                const auto [vk_buffer, offset] =
-                    buffer_cache.ObtainBuffer(address, size, desc.is_written, true);
-                const u32 fmt_stride = AmdGpu::NumBits(vsharp.GetDataFmt()) >> 3;
-                ASSERT_MSG(fmt_stride == vsharp.GetStride(),
-                           "Texel buffer stride must match format stride");
-                const u32 offset_aligned = Common::AlignDown(offset, alignment);
-                const u32 adjust = offset - offset_aligned;
-                ASSERT(adjust % fmt_stride == 0);
-                push_data.AddOffset(binding.buffer, adjust / fmt_stride);
-                buffer_view = vk_buffer->View(offset_aligned, size + adjust, desc.is_written,
-                                              vsharp.GetDataFmt(), vsharp.GetNumberFmt());
-                const auto dst_access = desc.is_written ? vk::AccessFlagBits2::eShaderWrite
-                                                        : vk::AccessFlagBits2::eShaderRead;
-                if (auto barrier = vk_buffer->GetBarrier(
-                        dst_access, vk::PipelineStageFlagBits2::eVertexShader)) {
-                    buffer_barriers.emplace_back(*barrier);
-                }
-                if (desc.is_written) {
-                    texture_cache.InvalidateMemoryFromGPU(address, size);
-                }
-            }
-            set_writes.push_back({
-                .dstSet = VK_NULL_HANDLE,
-                .dstBinding = binding.unified++,
-                .dstArrayElement = 0,
-                .descriptorCount = 1,
-                .descriptorType = desc.is_written ? vk::DescriptorType::eStorageTexelBuffer
-                                                  : vk::DescriptorType::eUniformTexelBuffer,
-                .pTexelBufferView = &buffer_view,
-            });
-            ++binding.buffer;
-        }
+        BindBuffers(buffer_cache, texture_cache, *stage, binding, push_data, set_writes,
+                    buffer_barriers);
 
         BindTextures(texture_cache, *stage, binding, set_writes);
-
-        for (const auto& sampler : stage->samplers) {
-            auto ssharp = sampler.GetSharp(*stage);
-            if (ssharp.force_degamma) {
-                LOG_WARNING(Render_Vulkan, "Texture requires gamma correction");
-            }
-            if (sampler.disable_aniso) {
-                const auto& tsharp = stage->images[sampler.associated_image].GetSharp(*stage);
-                if (tsharp.base_level == 0 && tsharp.last_level == 0) {
-                    ssharp.max_aniso.Assign(AmdGpu::AnisoRatio::One);
-                }
-            }
-            const auto vk_sampler = texture_cache.GetSampler(ssharp);
-            image_infos.emplace_back(vk_sampler, VK_NULL_HANDLE, vk::ImageLayout::eGeneral);
-            set_writes.push_back({
-                .dstSet = VK_NULL_HANDLE,
-                .dstBinding = binding.unified++,
-                .dstArrayElement = 0,
-                .descriptorCount = 1,
-                .descriptorType = vk::DescriptorType::eSampler,
-                .pImageInfo = &image_infos.back(),
-            });
-        }
     }
 
     const auto cmdbuf = scheduler.CommandBuffer();
+    SCOPE_EXIT {
+        cmdbuf.pushConstants(*pipeline_layout, gp_stage_flags, 0U, sizeof(push_data), &push_data);
+        cmdbuf.bindPipeline(vk::PipelineBindPoint::eGraphics, Handle());
+    };
+
+    if (set_writes.empty()) {
+        return;
+    }
 
     if (!buffer_barriers.empty()) {
         const auto dependencies = vk::DependencyInfo{
@@ -518,22 +429,18 @@ void GraphicsPipeline::BindResources(const Liverpool::Regs& regs,
         cmdbuf.pipelineBarrier2(dependencies);
     }
 
-    if (!set_writes.empty()) {
-        if (uses_push_descriptors) {
-            cmdbuf.pushDescriptorSetKHR(vk::PipelineBindPoint::eGraphics, *pipeline_layout, 0,
-                                        set_writes);
-        } else {
-            const auto desc_set = desc_heap.Commit(*desc_layout);
-            for (auto& set_write : set_writes) {
-                set_write.dstSet = desc_set;
-            }
-            instance.GetDevice().updateDescriptorSets(set_writes, {});
-            cmdbuf.bindDescriptorSets(vk::PipelineBindPoint::eGraphics, *pipeline_layout, 0,
-                                      desc_set, {});
-        }
+    // Bind descriptor set.
+    if (uses_push_descriptors) {
+        cmdbuf.pushDescriptorSetKHR(vk::PipelineBindPoint::eGraphics, *pipeline_layout, 0,
+                                    set_writes);
+        return;
     }
-    cmdbuf.pushConstants(*pipeline_layout, gp_stage_flags, 0U, sizeof(push_data), &push_data);
-    cmdbuf.bindPipeline(vk::PipelineBindPoint::eGraphics, Handle());
+    const auto desc_set = desc_heap.Commit(*desc_layout);
+    for (auto& set_write : set_writes) {
+        set_write.dstSet = desc_set;
+    }
+    instance.GetDevice().updateDescriptorSets(set_writes, {});
+    cmdbuf.bindDescriptorSets(vk::PipelineBindPoint::eGraphics, *pipeline_layout, 0, desc_set, {});
 }
 
 } // namespace Vulkan

src/video_core/renderer_vulkan/vk_pipeline_common.cpp

@@ -4,6 +4,7 @@
 #include <boost/container/static_vector.hpp>
 
 #include "shader_recompiler/info.h"
+#include "video_core/buffer_cache/buffer_cache.h"
 #include "video_core/renderer_vulkan/vk_instance.h"
 #include "video_core/renderer_vulkan/vk_pipeline_common.h"
 #include "video_core/renderer_vulkan/vk_scheduler.h"
@@ -12,6 +13,8 @@
 namespace Vulkan {
 
 boost::container::static_vector<vk::DescriptorImageInfo, 32> Pipeline::image_infos;
+boost::container::static_vector<vk::BufferView, 8> Pipeline::buffer_views;
+boost::container::static_vector<vk::DescriptorBufferInfo, 32> Pipeline::buffer_infos;
 
 Pipeline::Pipeline(const Instance& instance_, Scheduler& scheduler_, DescriptorHeap& desc_heap_,
                    vk::PipelineCache pipeline_cache)
@@ -19,12 +22,133 @@ Pipeline::Pipeline(const Instance& instance_, Scheduler& scheduler_, DescriptorH
 
 Pipeline::~Pipeline() = default;
 
+void Pipeline::BindBuffers(VideoCore::BufferCache& buffer_cache,
+                           VideoCore::TextureCache& texture_cache, const Shader::Info& stage,
+                           Shader::Backend::Bindings& binding, Shader::PushData& push_data,
+                           DescriptorWrites& set_writes, BufferBarriers& buffer_barriers) const {
+    using BufferBindingInfo = std::pair<VideoCore::BufferId, AmdGpu::Buffer>;
+    static boost::container::static_vector<BufferBindingInfo, 32> buffer_bindings;
+
+    buffer_bindings.clear();
+
+    for (const auto& desc : stage.buffers) {
+        const auto vsharp = desc.GetSharp(stage);
+        if (!desc.is_gds_buffer && vsharp.base_address != 0 && vsharp.GetSize() > 0) {
+            const auto buffer_id = buffer_cache.FindBuffer(vsharp.base_address, vsharp.GetSize());
+            buffer_bindings.emplace_back(buffer_id, vsharp);
+        } else {
+            buffer_bindings.emplace_back(VideoCore::BufferId{}, vsharp);
+        }
+    }
+
+    using TexBufferBindingInfo = std::pair<VideoCore::BufferId, AmdGpu::Buffer>;
+    static boost::container::static_vector<TexBufferBindingInfo, 32> texbuffer_bindings;
+
+    texbuffer_bindings.clear();
+
+    for (const auto& desc : stage.texture_buffers) {
+        const auto vsharp = desc.GetSharp(stage);
+        if (vsharp.base_address != 0 && vsharp.GetSize() > 0 &&
+            vsharp.GetDataFmt() != AmdGpu::DataFormat::FormatInvalid) {
+            const auto buffer_id = buffer_cache.FindBuffer(vsharp.base_address, vsharp.GetSize());
+            texbuffer_bindings.emplace_back(buffer_id, vsharp);
+        } else {
+            texbuffer_bindings.emplace_back(VideoCore::BufferId{}, vsharp);
+        }
+    }
+
+    // Second pass to re-bind buffers that were updated after binding
+    for (u32 i = 0; i < buffer_bindings.size(); i++) {
+        const auto& [buffer_id, vsharp] = buffer_bindings[i];
+        const auto& desc = stage.buffers[i];
+        const bool is_storage = desc.IsStorage(vsharp);
+        if (!buffer_id) {
+            if (desc.is_gds_buffer) {
+                const auto* gds_buf = buffer_cache.GetGdsBuffer();
+                buffer_infos.emplace_back(gds_buf->Handle(), 0, gds_buf->SizeBytes());
+            } else if (instance.IsNullDescriptorSupported()) {
+                buffer_infos.emplace_back(VK_NULL_HANDLE, 0, VK_WHOLE_SIZE);
+            } else {
+                auto& null_buffer = buffer_cache.GetBuffer(VideoCore::NULL_BUFFER_ID);
+                buffer_infos.emplace_back(null_buffer.Handle(), 0, VK_WHOLE_SIZE);
+            }
+        } else {
+            const auto [vk_buffer, offset] = buffer_cache.ObtainBuffer(
+                vsharp.base_address, vsharp.GetSize(), desc.is_written, false, buffer_id);
+            const u32 alignment =
+                is_storage ? instance.StorageMinAlignment() : instance.UniformMinAlignment();
+            const u32 offset_aligned = Common::AlignDown(offset, alignment);
+            const u32 adjust = offset - offset_aligned;
+            ASSERT(adjust % 4 == 0);
+            push_data.AddOffset(binding.buffer, adjust);
+            buffer_infos.emplace_back(vk_buffer->Handle(), offset_aligned,
+                                      vsharp.GetSize() + adjust);
+        }
+
+        set_writes.push_back({
+            .dstSet = VK_NULL_HANDLE,
+            .dstBinding = binding.unified++,
+            .dstArrayElement = 0,
+            .descriptorCount = 1,
+            .descriptorType = is_storage ? vk::DescriptorType::eStorageBuffer
+                                         : vk::DescriptorType::eUniformBuffer,
+            .pBufferInfo = &buffer_infos.back(),
+        });
+        ++binding.buffer;
+    }
+
+    const auto null_buffer_view =
+        instance.IsNullDescriptorSupported() ? VK_NULL_HANDLE : buffer_cache.NullBufferView();
+    for (u32 i = 0; i < texbuffer_bindings.size(); i++) {
+        const auto& [buffer_id, vsharp] = texbuffer_bindings[i];
+        const auto& desc = stage.texture_buffers[i];
+        vk::BufferView& buffer_view = buffer_views.emplace_back(null_buffer_view);
+        if (buffer_id) {
+            const u32 alignment = instance.TexelBufferMinAlignment();
+            const auto [vk_buffer, offset] = buffer_cache.ObtainBuffer(
+                vsharp.base_address, vsharp.GetSize(), desc.is_written, true, buffer_id);
+            const u32 fmt_stride = AmdGpu::NumBits(vsharp.GetDataFmt()) >> 3;
+            ASSERT_MSG(fmt_stride == vsharp.GetStride(),
+                       "Texel buffer stride must match format stride");
+            const u32 offset_aligned = Common::AlignDown(offset, alignment);
+            const u32 adjust = offset - offset_aligned;
+            ASSERT(adjust % fmt_stride == 0);
+            push_data.AddOffset(binding.buffer, adjust / fmt_stride);
+            buffer_view =
+                vk_buffer->View(offset_aligned, vsharp.GetSize() + adjust, desc.is_written,
+                                vsharp.GetDataFmt(), vsharp.GetNumberFmt());
+            if (auto barrier =
+                    vk_buffer->GetBarrier(desc.is_written ? vk::AccessFlagBits2::eShaderWrite
+                                                          : vk::AccessFlagBits2::eShaderRead,
+                                          vk::PipelineStageFlagBits2::eComputeShader)) {
+                buffer_barriers.emplace_back(*barrier);
+            }
+            if (desc.is_written) {
+                texture_cache.InvalidateMemoryFromGPU(vsharp.base_address, vsharp.GetSize());
+            }
+        }
+
+        set_writes.push_back({
+            .dstSet = VK_NULL_HANDLE,
+            .dstBinding = binding.unified++,
+            .dstArrayElement = 0,
+            .descriptorCount = 1,
+            .descriptorType = desc.is_written ? vk::DescriptorType::eStorageTexelBuffer
+                                              : vk::DescriptorType::eUniformTexelBuffer,
+            .pTexelBufferView = &buffer_view,
+        });
+        ++binding.buffer;
+    }
+}
+
 void Pipeline::BindTextures(VideoCore::TextureCache& texture_cache, const Shader::Info& stage,
                             Shader::Backend::Bindings& binding,
                             DescriptorWrites& set_writes) const {
 
     using ImageBindingInfo = std::tuple<VideoCore::ImageId, AmdGpu::Image, Shader::ImageResource>;
-    boost::container::static_vector<ImageBindingInfo, 32> image_bindings;
+    static boost::container::static_vector<ImageBindingInfo, 32> image_bindings;
+
+    image_bindings.clear();
 
     for (const auto& image_desc : stage.images) {
         const auto tsharp = image_desc.GetSharp(stage);
@@ -76,6 +200,26 @@ void Pipeline::BindTextures(VideoCore::TextureCache& texture_cache, const Shader
             .pImageInfo = &image_infos.back(),
         });
     }
+
+    for (const auto& sampler : stage.samplers) {
+        auto ssharp = sampler.GetSharp(stage);
+        if (sampler.disable_aniso) {
+            const auto& tsharp = stage.images[sampler.associated_image].GetSharp(stage);
+            if (tsharp.base_level == 0 && tsharp.last_level == 0) {
+                ssharp.max_aniso.Assign(AmdGpu::AnisoRatio::One);
+            }
+        }
+        const auto vk_sampler = texture_cache.GetSampler(ssharp);
+        image_infos.emplace_back(vk_sampler, VK_NULL_HANDLE, vk::ImageLayout::eGeneral);
+        set_writes.push_back({
+            .dstSet = VK_NULL_HANDLE,
+            .dstBinding = binding.unified++,
+            .dstArrayElement = 0,
+            .descriptorCount = 1,
+            .descriptorType = vk::DescriptorType::eSampler,
+            .pImageInfo = &image_infos.back(),
+        });
+    }
 }
 
 } // namespace Vulkan

src/video_core/renderer_vulkan/vk_pipeline_common.h

@@ -33,6 +33,13 @@ public:
     }
 
     using DescriptorWrites = boost::container::small_vector<vk::WriteDescriptorSet, 16>;
+    using BufferBarriers = boost::container::small_vector<vk::BufferMemoryBarrier2, 16>;
+
+    void BindBuffers(VideoCore::BufferCache& buffer_cache, VideoCore::TextureCache& texture_cache,
+                     const Shader::Info& stage, Shader::Backend::Bindings& binding,
+                     Shader::PushData& push_data, DescriptorWrites& set_writes,
+                     BufferBarriers& buffer_barriers) const;
+
     void BindTextures(VideoCore::TextureCache& texture_cache, const Shader::Info& stage,
                       Shader::Backend::Bindings& binding, DescriptorWrites& set_writes) const;
 
@@ -44,6 +51,8 @@ protected:
     vk::UniquePipelineLayout pipeline_layout;
     vk::UniqueDescriptorSetLayout desc_layout;
     static boost::container::static_vector<vk::DescriptorImageInfo, 32> image_infos;
+    static boost::container::static_vector<vk::BufferView, 8> buffer_views;
+    static boost::container::static_vector<vk::DescriptorBufferInfo, 32> buffer_infos;
 };
 
 } // namespace Vulkan

src/video_core/renderer_vulkan/vk_rasterizer.cpp

@@ -98,10 +98,9 @@ void Rasterizer::DrawIndirect(bool is_indexed, VAddr address, u32 offset, u32 si
 
     const auto& vs_info = pipeline->GetStage(Shader::Stage::Vertex);
     buffer_cache.BindVertexBuffers(vs_info);
-    const u32 num_indices = buffer_cache.BindIndexBuffer(is_indexed, 0);
+    buffer_cache.BindIndexBuffer(is_indexed, 0);
 
-    const auto [buffer, base] = buffer_cache.ObtainBuffer(address, size, true);
-    const auto total_offset = base + offset;
+    const auto [buffer, base] = buffer_cache.ObtainBuffer(address + offset, size, false);
 
     BeginRendering(*pipeline);
     UpdateDynamicState(*pipeline);
@@ -110,9 +109,9 @@ void Rasterizer::DrawIndirect(bool is_indexed, VAddr address, u32 offset, u32 si
     // instance offsets will be automatically applied by Vulkan from indirect args buffer.
 
     if (is_indexed) {
-        cmdbuf.drawIndexedIndirect(buffer->Handle(), total_offset, 1, 0);
+        cmdbuf.drawIndexedIndirect(buffer->Handle(), base, 1, 0);
     } else {
-        cmdbuf.drawIndirect(buffer->Handle(), total_offset, 1, 0);
+        cmdbuf.drawIndirect(buffer->Handle(), base, 1, 0);
     }
 }
 
@@ -161,9 +160,8 @@ void Rasterizer::DispatchIndirect(VAddr address, u32 offset, u32 size) {
 
     scheduler.EndRendering();
     cmdbuf.bindPipeline(vk::PipelineBindPoint::eCompute, pipeline->Handle());
-    const auto [buffer, base] = buffer_cache.ObtainBuffer(address, size, true);
-    const auto total_offset = base + offset;
-    cmdbuf.dispatchIndirect(buffer->Handle(), total_offset);
+    const auto [buffer, base] = buffer_cache.ObtainBuffer(address + offset, size, false);
+    cmdbuf.dispatchIndirect(buffer->Handle(), base);
 }
 
 u64 Rasterizer::Flush() {
@@ -260,8 +258,8 @@ void Rasterizer::BeginRendering(const GraphicsPipeline& pipeline) {
     scheduler.BeginRendering(state);
 }
 
-void Rasterizer::InlineDataToGds(u32 gds_offset, u32 value) {
-    buffer_cache.InlineDataToGds(gds_offset, value);
+void Rasterizer::InlineData(VAddr address, const void* value, u32 num_bytes, bool is_gds) {
+    buffer_cache.InlineData(address, value, num_bytes, is_gds);
 }
 
 u32 Rasterizer::ReadDataFromGds(u32 gds_offset) {

src/video_core/renderer_vulkan/vk_rasterizer.h

@@ -42,7 +42,7 @@ public:
     void ScopedMarkerInsert(const std::string_view& str);
     void ScopedMarkerInsertColor(const std::string_view& str, const u32 color);
 
-    void InlineDataToGds(u32 gds_offset, u32 value);
+    void InlineData(VAddr address, const void* value, u32 num_bytes, bool is_gds);
     u32 ReadDataFromGds(u32 gsd_offset);
     void InvalidateMemory(VAddr addr, u64 size);
     void MapMemory(VAddr addr, u64 size);