VideoBackends: Add Metal renderer

Source/Core/Core/CMakeLists.txt

@@ -631,6 +631,10 @@ if(ENABLE_VULKAN)
   target_link_libraries(core PUBLIC videovulkan)
 endif()
 
+if(APPLE)
+  target_link_libraries(core PUBLIC videometal)
+endif()
+
 if(USE_MGBA)
   target_sources(core PRIVATE
     HW/GBACore.cpp

Source/Core/VideoBackends/CMakeLists.txt

@@ -8,6 +8,10 @@ if(CMAKE_SYSTEM_NAME STREQUAL "Windows")
   add_subdirectory(D3D12)
 endif()
 
+if(APPLE)
+  add_subdirectory(Metal)
+endif()
+
 if(ENABLE_VULKAN)
   add_subdirectory(Vulkan)
 endif()

Source/Core/VideoBackends/D3D/D3DRender.cpp

@@ -150,8 +150,8 @@ void Renderer::DrawIndexed(u32 base_index, u32 num_indices, u32 base_vertex)
   D3D::context->DrawIndexed(num_indices, base_index, base_vertex);
 }
 
-void Renderer::DispatchComputeShader(const AbstractShader* shader, u32 groups_x, u32 groups_y,
+void Renderer::DispatchComputeShader(const AbstractShader* shader, u32 groupsize_x, u32 groupsize_y,
-                                     u32 groups_z)
+                                     u32 groupsize_z, u32 groups_x, u32 groups_y, u32 groups_z)
 {
   D3D::stateman->SetComputeShader(static_cast<const DXShader*>(shader)->GetD3DComputeShader());
   D3D::stateman->SyncComputeBindings();

Source/Core/VideoBackends/D3D/D3DRender.h

@@ -57,8 +57,8 @@ public:
                    float far_depth) override;
   void Draw(u32 base_vertex, u32 num_vertices) override;
   void DrawIndexed(u32 base_index, u32 num_indices, u32 base_vertex) override;
-  void DispatchComputeShader(const AbstractShader* shader, u32 groups_x, u32 groups_y,
+  void DispatchComputeShader(const AbstractShader* shader, u32 groupsize_x, u32 groupsize_y,
-                             u32 groups_z) override;
+                             u32 groupsize_z, u32 groups_x, u32 groups_y, u32 groups_z) override;
   void BindBackbuffer(const ClearColor& clear_color = {}) override;
   void PresentBackbuffer() override;
   void SetFullscreen(bool enable_fullscreen) override;

Source/Core/VideoBackends/D3D12/D3D12Renderer.cpp

@@ -365,8 +365,8 @@ void Renderer::DrawIndexed(u32 base_index, u32 num_indices, u32 base_vertex)
   g_dx_context->GetCommandList()->DrawIndexedInstanced(num_indices, 1, base_index, base_vertex, 0);
 }
 
-void Renderer::DispatchComputeShader(const AbstractShader* shader, u32 groups_x, u32 groups_y,
+void Renderer::DispatchComputeShader(const AbstractShader* shader, u32 groupsize_x, u32 groupsize_y,
-                                     u32 groups_z)
+                                     u32 groupsize_z, u32 groups_x, u32 groups_y, u32 groups_z)
 {
   SetRootSignatures();
   SetDescriptorHeaps();

Source/Core/VideoBackends/D3D12/D3D12Renderer.h

@@ -69,8 +69,8 @@ public:
                    float far_depth) override;
   void Draw(u32 base_vertex, u32 num_vertices) override;
   void DrawIndexed(u32 base_index, u32 num_indices, u32 base_vertex) override;
-  void DispatchComputeShader(const AbstractShader* shader, u32 groups_x, u32 groups_y,
+  void DispatchComputeShader(const AbstractShader* shader, u32 groupsize_x, u32 groupsize_y,
-                             u32 groups_z) override;
+                             u32 groupsize_z, u32 groups_x, u32 groups_y, u32 groups_z) override;
   void BindBackbuffer(const ClearColor& clear_color = {}) override;
   void PresentBackbuffer() override;
 

Source/Core/VideoBackends/Metal/CMakeLists.txt

@@ -0,0 +1,37 @@
+add_library(videometal
+  MRCHelpers.h
+  MTLBoundingBox.mm
+  MTLBoundingBox.h
+  MTLMain.mm
+  MTLObjectCache.h
+  MTLObjectCache.mm
+  MTLPerfQuery.mm
+  MTLPerfQuery.h
+  MTLPipeline.mm
+  MTLPipeline.h
+  MTLRenderer.mm
+  MTLRenderer.h
+  MTLShader.h
+  MTLStateTracker.mm
+  MTLStateTracker.h
+  MTLTexture.mm
+  MTLTexture.h
+  MTLUtil.mm
+  MTLUtil.h
+  MTLVertexManager.mm
+  MTLVertexManager.h
+  VideoBackend.h
+)
+
+find_library(METAL_LIBRARY Metal)
+find_library(QUARTZCORE_LIBRARY QuartzCore)
+
+target_link_libraries(videometal
+PUBLIC
+  common
+  videocommon
+PRIVATE
+  spirv_cross
+  ${METAL_LIBRARY}
+  ${QUARTZCORE_LIBRARY}
+)

Source/Core/VideoBackends/Metal/MRCHelpers.h

@@ -0,0 +1,81 @@
+// Copyright 2022 Dolphin Emulator Project
+// SPDX-License-Identifier: GPL-2.0-or-later
+
+// clang-format off
+#ifndef __OBJC__
+  #error This header is for use with Objective-C++ only.
+#endif
+#if __has_feature(objc_arc)
+  #error This file is for manual reference counting!  Compile without -fobjc-arc
+#endif
+// clang-format on
+
+#pragma once
+
+#include <cstddef>
+#include <utility>
+
+/// Managed Obj-C pointer
+template <typename T>
+class MRCOwned
+{
+  T ptr;
+  MRCOwned(T ptr) : ptr(ptr) {}
+
+public:
+  MRCOwned() : ptr(nullptr) {}
+  MRCOwned(std::nullptr_t) : ptr(nullptr) {}
+  MRCOwned(MRCOwned&& other) : ptr(other.ptr) { other.ptr = nullptr; }
+  MRCOwned(const MRCOwned& other) : ptr(other.ptr) { [ptr retain]; }
+  ~MRCOwned()
+  {
+    if (ptr)
+      [ptr release];
+  }
+  operator T() const { return ptr; }
+  MRCOwned& operator=(const MRCOwned& other)
+  {
+    [other.ptr retain];
+    if (ptr)
+      [ptr release];
+    ptr = other.ptr;
+    return *this;
+  }
+  MRCOwned& operator=(MRCOwned&& other)
+  {
+    std::swap(ptr, other.ptr);
+    return *this;
+  }
+  void Reset()
+  {
+    [ptr release];
+    ptr = nullptr;
+  }
+  T Disown()
+  {
+    T tmp = ptr;
+    ptr = nullptr;
+    return tmp;
+  }
+  T Get() const { return ptr; }
+  static MRCOwned Transfer(T ptr) { return MRCOwned(ptr); }
+  static MRCOwned Retain(T ptr)
+  {
+    [ptr retain];
+    return MRCOwned(ptr);
+  }
+};
+
+/// Take ownership of an Obj-C pointer (equivalent to __bridge_transfer)
+template <typename T>
+static inline MRCOwned<T> MRCTransfer(T ptr)
+{
+  return MRCOwned<T>::Transfer(ptr);
+}
+
+/// Retain an Obj-C pointer (equivalent to __bridge)
+template <typename T>
+static inline MRCOwned<T> MRCRetain(T ptr)
+{
+  return MRCOwned<T>::Retain(ptr);
+}

Source/Core/VideoBackends/Metal/MTLBoundingBox.h

@@ -0,0 +1,30 @@
+// Copyright 2022 Dolphin Emulator Project
+// SPDX-License-Identifier: GPL-2.0-or-later
+
+#include "VideoCommon/BoundingBox.h"
+
+#include <Metal/Metal.h>
+
+#include "VideoBackends/Metal/MRCHelpers.h"
+
+namespace Metal
+{
+class BoundingBox final : public ::BoundingBox
+{
+public:
+  ~BoundingBox() override;
+
+  bool Initialize() override;
+
+protected:
+  std::vector<BBoxType> Read(u32 index, u32 length) override;
+  void Write(u32 index, const std::vector<BBoxType>& values) override;
+
+private:
+  BBoxType* m_cpu_buffer_ptr;
+  MRCOwned<id<MTLFence>> m_download_fence;
+  MRCOwned<id<MTLFence>> m_upload_fence;
+  MRCOwned<id<MTLBuffer>> m_cpu_buffer;
+  MRCOwned<id<MTLBuffer>> m_gpu_buffer;
+};
+}  // namespace Metal

Source/Core/VideoBackends/Metal/MTLBoundingBox.mm

@@ -0,0 +1,97 @@
+// Copyright 2022 Dolphin Emulator Project
+// SPDX-License-Identifier: GPL-2.0-or-later
+
+#include "VideoBackends/Metal/MTLBoundingBox.h"
+
+#include "VideoBackends/Metal/MTLObjectCache.h"
+#include "VideoBackends/Metal/MTLStateTracker.h"
+
+static constexpr size_t BUFFER_SIZE = sizeof(BBoxType) * NUM_BBOX_VALUES;
+
+Metal::BoundingBox::~BoundingBox()
+{
+  if (g_state_tracker)
+    g_state_tracker->SetBBoxBuffer(nullptr, nullptr, nullptr);
+}
+
+bool Metal::BoundingBox::Initialize()
+{
+  const MTLResourceOptions gpu_storage_mode =
+      g_features.unified_memory ? MTLResourceStorageModeShared : MTLResourceStorageModePrivate;
+  const MTLResourceOptions gpu_options = gpu_storage_mode | MTLResourceHazardTrackingModeUntracked;
+  const id<MTLDevice> dev = g_device;
+  m_upload_fence = MRCTransfer([dev newFence]);
+  [m_upload_fence setLabel:@"BBox Upload Fence"];
+  m_download_fence = MRCTransfer([dev newFence]);
+  [m_download_fence setLabel:@"BBox Download Fence"];
+  m_gpu_buffer = MRCTransfer([dev newBufferWithLength:BUFFER_SIZE options:gpu_options]);
+  if (g_features.unified_memory)
+  {
+    [m_gpu_buffer setLabel:@"BBox Buffer"];
+    m_cpu_buffer_ptr = static_cast<BBoxType*>([m_gpu_buffer contents]);
+  }
+  else
+  {
+    m_cpu_buffer = MRCTransfer([dev newBufferWithLength:BUFFER_SIZE
+                                                options:MTLResourceStorageModeShared]);
+    m_cpu_buffer_ptr = static_cast<BBoxType*>([m_cpu_buffer contents]);
+    [m_gpu_buffer setLabel:@"BBox GPU Buffer"];
+    [m_cpu_buffer setLabel:@"BBox CPU Buffer"];
+  }
+  g_state_tracker->SetBBoxBuffer(m_gpu_buffer, m_upload_fence, m_download_fence);
+  return true;
+}
+
+std::vector<BBoxType> Metal::BoundingBox::Read(u32 index, u32 length)
+{
+  @autoreleasepool
+  {
+    g_state_tracker->EndRenderPass();
+    if (!g_features.unified_memory)
+    {
+      id<MTLBlitCommandEncoder> download = [g_state_tracker->GetRenderCmdBuf() blitCommandEncoder];
+      [download setLabel:@"BBox Download"];
+      [download waitForFence:m_download_fence];
+      [download copyFromBuffer:m_gpu_buffer
+                  sourceOffset:0
+                      toBuffer:m_cpu_buffer
+             destinationOffset:0
+                          size:BUFFER_SIZE];
+      [download endEncoding];
+    }
+    g_state_tracker->FlushEncoders();
+    g_state_tracker->WaitForFlushedEncoders();
+    return std::vector<BBoxType>(m_cpu_buffer_ptr + index, m_cpu_buffer_ptr + index + length);
+  }
+}
+
+void Metal::BoundingBox::Write(u32 index, const std::vector<BBoxType>& values)
+{
+  const u32 size = values.size() * sizeof(BBoxType);
+  if (g_features.unified_memory && !g_state_tracker->HasUnflushedData() &&
+      !g_state_tracker->GPUBusy())
+  {
+    // We can just write directly to the buffer!
+    memcpy(m_cpu_buffer_ptr + index, values.data(), size);
+  }
+  else
+  {
+    @autoreleasepool
+    {
+      StateTracker::Map map = g_state_tracker->Allocate(StateTracker::UploadBuffer::Other, size,
+                                                        StateTracker::AlignMask::Other);
+      memcpy(map.cpu_buffer, values.data(), size);
+      g_state_tracker->EndRenderPass();
+      id<MTLBlitCommandEncoder> upload = [g_state_tracker->GetRenderCmdBuf() blitCommandEncoder];
+      [upload setLabel:@"BBox Upload"];
+      [upload waitForFence:m_download_fence];
+      [upload copyFromBuffer:map.gpu_buffer
+                sourceOffset:map.gpu_offset
+                    toBuffer:m_gpu_buffer
+           destinationOffset:index * sizeof(BBoxType)
+                        size:size];
+      [upload updateFence:m_upload_fence];
+      [upload endEncoding];
+    }
+  }
+}

Source/Core/VideoBackends/Metal/MTLMain.mm

@@ -0,0 +1,157 @@
+// Copyright 2022 Dolphin Emulator Project
+// SPDX-License-Identifier: GPL-2.0-or-later
+
+#include "VideoBackends/Metal/VideoBackend.h"
+
+#include <AppKit/AppKit.h>
+#include <Metal/Metal.h>
+#include <QuartzCore/QuartzCore.h>
+
+#include "Common/Common.h"
+#include "Common/MsgHandler.h"
+
+#include "VideoBackends/Metal/MTLObjectCache.h"
+#include "VideoBackends/Metal/MTLPerfQuery.h"
+#include "VideoBackends/Metal/MTLRenderer.h"
+#include "VideoBackends/Metal/MTLStateTracker.h"
+#include "VideoBackends/Metal/MTLUtil.h"
+#include "VideoBackends/Metal/MTLVertexManager.h"
+
+#include "VideoCommon/FramebufferManager.h"
+#include "VideoCommon/VideoCommon.h"
+#include "VideoCommon/VideoConfig.h"
+
+std::string Metal::VideoBackend::GetName() const
+{
+  return NAME;
+}
+
+std::string Metal::VideoBackend::GetDisplayName() const
+{
+  // i18n: Apple's Metal graphics API (https://developer.apple.com/metal/)
+  return _trans("Metal");
+}
+
+std::optional<std::string> Metal::VideoBackend::GetWarningMessage() const
+{
+  if (Util::GetAdapterList().empty())
+  {
+    return _trans("No Metal-compatible GPUs were found.  "
+                  "Use the OpenGL backend or upgrade your computer/GPU");
+  }
+
+  return std::nullopt;
+}
+
+static bool WindowSystemTypeSupportsMetal(WindowSystemType type)
+{
+  switch (type)
+  {
+  case WindowSystemType::MacOS:
+    return true;
+  default:
+    return false;
+  }
+}
+
+bool Metal::VideoBackend::Initialize(const WindowSystemInfo& wsi)
+{
+  @autoreleasepool
+  {
+    if (!WindowSystemTypeSupportsMetal(wsi.type) || !wsi.render_surface)
+    {
+      PanicAlertFmt("Bad WindowSystemInfo for Metal renderer.");
+      return false;
+    }
+
+    auto devs = Util::GetAdapterList();
+    if (devs.empty())
+    {
+      PanicAlertFmt("No Metal GPUs detected.");
+      return false;
+    }
+
+    Util::PopulateBackendInfo(&g_Config);
+    Util::PopulateBackendInfoAdapters(&g_Config, devs);
+
+    // Since we haven't called InitializeShared yet, iAdapter may be out of range,
+    // so we have to check it ourselves.
+    size_t selected_adapter_index = static_cast<size_t>(g_Config.iAdapter);
+    if (selected_adapter_index >= devs.size())
+    {
+      WARN_LOG_FMT(VIDEO, "Metal adapter index out of range, selecting default adapter.");
+      selected_adapter_index = 0;
+    }
+    MRCOwned<id<MTLDevice>> adapter = std::move(devs[selected_adapter_index]);
+    Util::PopulateBackendInfoFeatures(&g_Config, adapter);
+
+    // With the backend information populated, we can now initialize videocommon.
+    InitializeShared();
+
+    MRCOwned<CAMetalLayer*> layer = MRCRetain(static_cast<CAMetalLayer*>(wsi.render_surface));
+    [layer setDevice:adapter];
+    if (Util::ToAbstract([layer pixelFormat]) == AbstractTextureFormat::Undefined)
+      [layer setPixelFormat:MTLPixelFormatBGRA8Unorm];
+    CGSize size = [layer bounds].size;
+    float scale = [layer contentsScale];
+
+    ObjectCache::Initialize(std::move(adapter));
+    g_state_tracker = std::make_unique<StateTracker>();
+    g_renderer = std::make_unique<Renderer>(std::move(layer), size.width * scale,
+                                            size.height * scale, scale);
+    g_vertex_manager = std::make_unique<VertexManager>();
+    g_perf_query = std::make_unique<PerfQuery>();
+    g_framebuffer_manager = std::make_unique<FramebufferManager>();
+    g_texture_cache = std::make_unique<TextureCacheBase>();
+    g_shader_cache = std::make_unique<VideoCommon::ShaderCache>();
+
+    if (!g_vertex_manager->Initialize() || !g_shader_cache->Initialize() ||
+        !g_renderer->Initialize() || !g_framebuffer_manager->Initialize() ||
+        !g_texture_cache->Initialize())
+    {
+      PanicAlertFmt("Failed to initialize renderer classes");
+      Shutdown();
+      return false;
+    }
+
+    g_shader_cache->InitializeShaderCache();
+
+    return true;
+  }
+}
+
+void Metal::VideoBackend::Shutdown()
+{
+  g_shader_cache->Shutdown();
+  g_renderer->Shutdown();
+
+  g_shader_cache.reset();
+  g_texture_cache.reset();
+  g_framebuffer_manager.reset();
+  g_perf_query.reset();
+  g_vertex_manager.reset();
+  g_renderer.reset();
+  g_state_tracker.reset();
+  ObjectCache::Shutdown();
+  ShutdownShared();
+}
+
+void Metal::VideoBackend::InitBackendInfo()
+{
+  @autoreleasepool
+  {
+    Util::PopulateBackendInfo(&g_Config);
+    Util::PopulateBackendInfoAdapters(&g_Config, Util::GetAdapterList());
+  }
+}
+
+void Metal::VideoBackend::PrepareWindow(WindowSystemInfo& wsi)
+{
+  if (wsi.type != WindowSystemType::MacOS)
+    return;
+  NSView* view = static_cast<NSView*>(wsi.render_surface);
+  CAMetalLayer* layer = [CAMetalLayer layer];
+  [view setWantsLayer:YES];
+  [view setLayer:layer];
+  wsi.render_surface = layer;
+}

Source/Core/VideoBackends/Metal/MTLObjectCache.h

@@ -0,0 +1,91 @@
+// Copyright 2022 Dolphin Emulator Project
+// SPDX-License-Identifier: GPL-2.0-or-later
+
+#pragma once
+
+#include <Metal/Metal.h>
+#include <memory>
+
+#include "VideoBackends/Metal/MRCHelpers.h"
+
+#include "VideoCommon/RenderState.h"
+
+namespace Metal
+{
+extern MRCOwned<id<MTLDevice>> g_device;
+extern MRCOwned<id<MTLCommandQueue>> g_queue;
+
+struct DepthStencilSelector
+{
+  u8 value;
+
+  DepthStencilSelector() : value(0) {}
+  DepthStencilSelector(bool update_enable, enum CompareMode cmp)
+      : value(update_enable | (static_cast<u32>(cmp) << 1))
+  {
+  }
+  DepthStencilSelector(DepthState state)
+      : DepthStencilSelector(state.testenable ? state.updateenable : false,
+                             state.testenable ? state.func : CompareMode::Always)
+  {
+  }
+
+  bool UpdateEnable() const { return value & 1; }
+  enum CompareMode CompareMode() const { return static_cast<enum CompareMode>(value >> 1); }
+
+  bool operator==(const DepthStencilSelector& other) { return value == other.value; }
+  bool operator!=(const DepthStencilSelector& other) { return !(*this == other); }
+  static constexpr size_t N_VALUES = 1 << 4;
+};
+
+struct SamplerSelector
+{
+  u8 value;
+  SamplerSelector() : value(0) {}
+  SamplerSelector(SamplerState state)
+  {
+    value = (static_cast<u32>(state.tm0.min_filter.Value()) << 0) |
+            (static_cast<u32>(state.tm0.mag_filter.Value()) << 1) |
+            (static_cast<u32>(state.tm0.mipmap_filter.Value()) << 2) |
+            (static_cast<u32>(state.tm0.anisotropic_filtering) << 3);
+    value |= (static_cast<u32>(state.tm0.wrap_u.Value()) +
+              3 * static_cast<u32>(state.tm0.wrap_v.Value()))
+             << 4;
+  }
+  FilterMode MinFilter() const { return static_cast<FilterMode>(value & 1); }
+  FilterMode MagFilter() const { return static_cast<FilterMode>((value >> 1) & 1); }
+  FilterMode MipFilter() const { return static_cast<FilterMode>((value >> 2) & 1); }
+  WrapMode WrapU() const { return static_cast<WrapMode>((value >> 4) % 3); }
+  WrapMode WrapV() const { return static_cast<WrapMode>((value >> 4) / 3); }
+  bool AnisotropicFiltering() const { return ((value >> 3) & 1); }
+
+  bool operator==(const SamplerSelector& other) { return value == other.value; }
+  bool operator!=(const SamplerSelector& other) { return !(*this == other); }
+  static constexpr size_t N_VALUES = (1 << 4) * 9;
+};
+
+class ObjectCache
+{
+  ObjectCache();
+
+public:
+  ~ObjectCache();
+
+  static void Initialize(MRCOwned<id<MTLDevice>> device);
+  static void Shutdown();
+
+  id<MTLDepthStencilState> GetDepthStencil(DepthStencilSelector sel) { return m_dss[sel.value]; }
+
+  id<MTLSamplerState> GetSampler(SamplerSelector sel) { return m_samplers[sel.value]; }
+
+  id<MTLSamplerState> GetSampler(SamplerState state) { return GetSampler(SamplerSelector(state)); }
+
+  void ReloadSamplers();
+
+private:
+  MRCOwned<id<MTLDepthStencilState>> m_dss[DepthStencilSelector::N_VALUES];
+  MRCOwned<id<MTLSamplerState>> m_samplers[SamplerSelector::N_VALUES];
+};
+
+extern std::unique_ptr<ObjectCache> g_object_cache;
+}  // namespace Metal

Source/Core/VideoBackends/Metal/MTLObjectCache.mm

@@ -0,0 +1,175 @@
+// Copyright 2022 Dolphin Emulator Project
+// SPDX-License-Identifier: GPL-2.0-or-later
+
+#include "VideoBackends/Metal/MTLObjectCache.h"
+
+#include "VideoCommon/VideoConfig.h"
+
+MRCOwned<id<MTLDevice>> Metal::g_device;
+MRCOwned<id<MTLCommandQueue>> Metal::g_queue;
+std::unique_ptr<Metal::ObjectCache> Metal::g_object_cache;
+
+static void SetupDepthStencil(
+    MRCOwned<id<MTLDepthStencilState>> (&dss)[Metal::DepthStencilSelector::N_VALUES]);
+static void SetupSamplers(MRCOwned<id<MTLSamplerState>> (&samplers)[Metal::SamplerSelector::N_VALUES]);
+
+Metal::ObjectCache::ObjectCache()
+{
+  SetupDepthStencil(m_dss);
+  SetupSamplers(m_samplers);
+}
+
+Metal::ObjectCache::~ObjectCache()
+{
+}
+
+void Metal::ObjectCache::Initialize(MRCOwned<id<MTLDevice>> device)
+{
+  g_device = std::move(device);
+  g_queue = MRCTransfer([g_device newCommandQueue]);
+  g_object_cache = std::unique_ptr<ObjectCache>(new ObjectCache);
+}
+
+void Metal::ObjectCache::Shutdown()
+{
+  g_object_cache.reset();
+  g_queue = nullptr;
+  g_device = nullptr;
+}
+
+// MARK: Depth Stencil State
+
+// clang-format off
+
+static MTLCompareFunction Convert(CompareMode mode)
+{
+  const bool invert_depth = !g_Config.backend_info.bSupportsReversedDepthRange;
+  switch (mode)
+  {
+  case CompareMode::Never:   return MTLCompareFunctionNever;
+  case CompareMode::Less:    return invert_depth ? MTLCompareFunctionGreater
+                                                 : MTLCompareFunctionLess;
+  case CompareMode::Equal:   return MTLCompareFunctionEqual;
+  case CompareMode::LEqual:  return invert_depth ? MTLCompareFunctionGreaterEqual
+                                                 : MTLCompareFunctionLessEqual;
+  case CompareMode::Greater: return invert_depth ? MTLCompareFunctionLess
+                                                 : MTLCompareFunctionGreater;
+  case CompareMode::NEqual:  return MTLCompareFunctionNotEqual;
+  case CompareMode::GEqual:  return invert_depth ? MTLCompareFunctionLessEqual
+                                                 : MTLCompareFunctionGreaterEqual;
+  case CompareMode::Always:  return MTLCompareFunctionAlways;
+  }
+}
+
+static const char* to_string(MTLCompareFunction compare)
+{
+  switch (compare)
+  {
+  case MTLCompareFunctionNever:        return "Never";
+  case MTLCompareFunctionGreater:      return "Greater";
+  case MTLCompareFunctionEqual:        return "Equal";
+  case MTLCompareFunctionGreaterEqual: return "GEqual";
+  case MTLCompareFunctionLess:         return "Less";
+  case MTLCompareFunctionNotEqual:     return "NEqual";
+  case MTLCompareFunctionLessEqual:    return "LEqual";
+  case MTLCompareFunctionAlways:       return "Always";
+  }
+}
+
+// clang-format on
+
+static void SetupDepthStencil(
+    MRCOwned<id<MTLDepthStencilState>> (&dss)[Metal::DepthStencilSelector::N_VALUES])
+{
+  auto desc = MRCTransfer([MTLDepthStencilDescriptor new]);
+  Metal::DepthStencilSelector sel;
+  for (size_t i = 0; i < std::size(dss); ++i)
+  {
+    sel.value = i;
+    MTLCompareFunction mcompare = Convert(sel.CompareMode());
+    [desc setDepthWriteEnabled:sel.UpdateEnable()];
+    [desc setDepthCompareFunction:mcompare];
+    [desc setLabel:[NSString stringWithFormat:@"DSS %s%s", to_string(mcompare),
+                                              sel.UpdateEnable() ? "+Write" : ""]];
+    dss[i] = MRCTransfer([Metal::g_device newDepthStencilStateWithDescriptor:desc]);
+  }
+}
+
+// MARK: Samplers
+
+// clang-format off
+
+static MTLSamplerMinMagFilter ConvertMinMag(FilterMode filter)
+{
+  switch (filter)
+  {
+  case FilterMode::Linear: return MTLSamplerMinMagFilterLinear;
+  case FilterMode::Near:   return MTLSamplerMinMagFilterNearest;
+  }
+}
+
+static MTLSamplerMipFilter ConvertMip(FilterMode filter)
+{
+  switch (filter)
+  {
+  case FilterMode::Linear: return MTLSamplerMipFilterLinear;
+  case FilterMode::Near:   return MTLSamplerMipFilterNearest;
+  }
+}
+
+static MTLSamplerAddressMode Convert(WrapMode wrap)
+{
+  switch (wrap)
+  {
+  case WrapMode::Clamp:  return MTLSamplerAddressModeClampToEdge;
+  case WrapMode::Mirror: return MTLSamplerAddressModeMirrorRepeat;
+  case WrapMode::Repeat: return MTLSamplerAddressModeRepeat;
+  }
+}
+
+static const char* to_string(FilterMode filter)
+{
+  switch (filter)
+  {
+  case FilterMode::Linear: return "Ln";
+  case FilterMode::Near:   return "Pt";
+  }
+}
+static const char* to_string(WrapMode wrap)
+{
+  switch (wrap)
+  {
+  case WrapMode::Clamp:  return "C";
+  case WrapMode::Mirror: return "M";
+  case WrapMode::Repeat: return "R";
+  }
+}
+
+// clang-format on
+
+static void SetupSamplers(MRCOwned<id<MTLSamplerState>> (&samplers)[Metal::SamplerSelector::N_VALUES])
+{
+  auto desc = MRCTransfer([MTLSamplerDescriptor new]);
+  Metal::SamplerSelector sel;
+  for (size_t i = 0; i < std::size(samplers); i++)
+  {
+    sel.value = i;
+    [desc setMinFilter:ConvertMinMag(sel.MinFilter())];
+    [desc setMagFilter:ConvertMinMag(sel.MagFilter())];
+    [desc setMipFilter:ConvertMip(sel.MipFilter())];
+    [desc setSAddressMode:Convert(sel.WrapU())];
+    [desc setTAddressMode:Convert(sel.WrapV())];
+    [desc setMaxAnisotropy:1 << (sel.AnisotropicFiltering() ? g_ActiveConfig.iMaxAnisotropy : 0)];
+    [desc setLabel:MRCTransfer([[NSString alloc]
+                       initWithFormat:@"%s%s%s %s%s%s", to_string(sel.MinFilter()),
+                                      to_string(sel.MagFilter()), to_string(sel.MipFilter()),
+                                      to_string(sel.WrapU()), to_string(sel.WrapV()),
+                                      sel.AnisotropicFiltering() ? "(AF)" : ""])];
+    samplers[i] = MRCTransfer([Metal::g_device newSamplerStateWithDescriptor:desc]);
+  }
+}
+
+void Metal::ObjectCache::ReloadSamplers()
+{
+  SetupSamplers(m_samplers);
+}

Source/Core/VideoBackends/Metal/MTLPerfQuery.h

@@ -0,0 +1,20 @@
+// Copyright 2022 Dolphin Emulator Project
+// SPDX-License-Identifier: GPL-2.0-or-later
+
+#pragma once
+
+#include "VideoCommon/PerfQueryBase.h"
+
+namespace Metal
+{
+class PerfQuery final : public PerfQueryBase
+{
+public:
+  void EnableQuery(PerfQueryGroup type) override {}
+  void DisableQuery(PerfQueryGroup type) override {}
+  void ResetQuery() override {}
+  u32 GetQueryResult(PerfQueryType type) override { return 0; }
+  void FlushResults() override {}
+  bool IsFlushed() const override { return true; }
+};
+}  // namespace Metal

Source/Core/VideoBackends/Metal/MTLPerfQuery.mm

@@ -0,0 +1,4 @@
+// Copyright 2022 Dolphin Emulator Project
+// SPDX-License-Identifier: GPL-2.0-or-later
+
+#include "VideoBackends/Metal/MTLPerfQuery.h"

Source/Core/VideoBackends/Metal/MTLPipeline.h

@@ -0,0 +1,64 @@
+// Copyright 2022 Dolphin Emulator Project
+// SPDX-License-Identifier: GPL-2.0-or-later
+
+#pragma once
+
+#include <Metal/Metal.h>
+
+#include "VideoBackends/Metal/MRCHelpers.h"
+#include "VideoBackends/Metal/MTLObjectCache.h"
+#include "VideoBackends/Metal/MTLShader.h"
+
+#include "VideoCommon/AbstractPipeline.h"
+#include "VideoCommon/AbstractShader.h"
+
+namespace Metal
+{
+class Pipeline final : public AbstractPipeline
+{
+public:
+  explicit Pipeline(MRCOwned<id<MTLRenderPipelineState>> pipeline,
+                    MTLRenderPipelineReflection* reflection, MTLPrimitiveType prim,
+                    MTLCullMode cull, DepthState depth, AbstractPipelineUsage usage);
+
+  id<MTLRenderPipelineState> Get() const { return m_pipeline; }
+  MTLPrimitiveType Prim() const { return m_prim; }
+  MTLCullMode Cull() const { return m_cull; }
+  DepthStencilSelector DepthStencil() const { return m_depth_stencil; }
+  AbstractPipelineUsage Usage() const { return m_usage; }
+  u32 GetTextures() const { return m_textures; }
+  u32 GetSamplers() const { return m_samplers; }
+  u32 GetVertexBuffers() const { return m_vertex_buffers; }
+  u32 GetFragmentBuffers() const { return m_fragment_buffers; }
+  bool UsesVertexBuffer(u32 index) const { return m_vertex_buffers & (1 << index); }
+  bool UsesFragmentBuffer(u32 index) const { return m_fragment_buffers & (1 << index); }
+
+private:
+  MRCOwned<id<MTLRenderPipelineState>> m_pipeline;
+  MTLPrimitiveType m_prim;
+  MTLCullMode m_cull;
+  DepthStencilSelector m_depth_stencil;
+  AbstractPipelineUsage m_usage;
+  u32 m_textures = 0;
+  u32 m_samplers = 0;
+  u32 m_vertex_buffers = 0;
+  u32 m_fragment_buffers = 0;
+};
+
+class ComputePipeline : public Shader
+{
+public:
+  explicit ComputePipeline(ShaderStage stage, MTLComputePipelineReflection* reflection,
+                           std::string msl, MRCOwned<id<MTLFunction>> shader,
+                           MRCOwned<id<MTLComputePipelineState>> pipeline);
+
+  id<MTLComputePipelineState> GetComputePipeline() const { return m_compute_pipeline; }
+  bool UsesTexture(u32 index) const { return m_textures & (1 << index); }
+  bool UsesBuffer(u32 index) const { return m_buffers & (1 << index); }
+
+private:
+  MRCOwned<id<MTLComputePipelineState>> m_compute_pipeline;
+  u32 m_textures = 0;
+  u32 m_buffers = 0;
+};
+}  // namespace Metal

Source/Core/VideoBackends/Metal/MTLPipeline.mm

@@ -0,0 +1,66 @@
+// Copyright 2022 Dolphin Emulator Project
+// SPDX-License-Identifier: GPL-2.0-or-later
+
+#include "VideoBackends/Metal/MTLPipeline.h"
+
+#include "Common/MsgHandler.h"
+
+static void MarkAsUsed(u32* list, u32 start, u32 length)
+{
+  for (u32 i = start; i < start + length; ++i)
+    *list |= 1 << i;
+}
+
+static void GetArguments(NSArray<MTLArgument*>* arguments, u32* textures, u32* samplers,
+                         u32* buffers)
+{
+  for (MTLArgument* argument in arguments)
+  {
+    const u32 idx = [argument index];
+    const u32 length = [argument arrayLength];
+    if (idx + length > 32)
+    {
+      PanicAlertFmt("Making a MTLPipeline with high argument index {:d}..<{:d} for {:s}",  //
+                    idx, idx + length, [[argument name] UTF8String]);
+      continue;
+    }
+    switch ([argument type])
+    {
+    case MTLArgumentTypeTexture:
+      if (textures)
+        MarkAsUsed(textures, idx, length);
+      else
+        PanicAlertFmt("Vertex function wants a texture!");
+      break;
+    case MTLArgumentTypeSampler:
+      if (samplers)
+        MarkAsUsed(samplers, idx, length);
+      else
+        PanicAlertFmt("Vertex function wants a sampler!");
+      break;
+    case MTLArgumentTypeBuffer:
+      MarkAsUsed(buffers, idx, length);
+      break;
+    default:
+      break;
+    }
+  }
+}
+
+Metal::Pipeline::Pipeline(MRCOwned<id<MTLRenderPipelineState>> pipeline,
+                          MTLRenderPipelineReflection* reflection, MTLPrimitiveType prim,
+                          MTLCullMode cull, DepthState depth, AbstractPipelineUsage usage)
+    : m_pipeline(std::move(pipeline)), m_prim(prim), m_cull(cull), m_depth_stencil(depth),
+      m_usage(usage)
+{
+  GetArguments([reflection vertexArguments], nullptr, nullptr, &m_vertex_buffers);
+  GetArguments([reflection fragmentArguments], &m_textures, &m_samplers, &m_fragment_buffers);
+}
+
+Metal::ComputePipeline::ComputePipeline(ShaderStage stage, MTLComputePipelineReflection* reflection,
+                                        std::string msl, MRCOwned<id<MTLFunction>> shader,
+                                        MRCOwned<id<MTLComputePipelineState>> pipeline)
+    : Shader(stage, std::move(msl), std::move(shader)), m_compute_pipeline(std::move(pipeline))
+{
+  GetArguments([reflection arguments], &m_textures, nullptr, &m_buffers);
+}

Source/Core/VideoBackends/Metal/MTLRenderer.h

@@ -0,0 +1,91 @@
+// Copyright 2022 Dolphin Emulator Project
+// SPDX-License-Identifier: GPL-2.0-or-later
+
+#pragma once
+
+#include <Metal/Metal.h>
+#include <QuartzCore/QuartzCore.h>
+
+#include "VideoCommon/RenderBase.h"
+
+#include "VideoBackends/Metal/MRCHelpers.h"
+
+namespace Metal
+{
+class Framebuffer;
+class Texture;
+
+class Renderer final : public ::Renderer
+{
+public:
+  Renderer(MRCOwned<CAMetalLayer*> layer, int width, int height, float layer_scale);
+  ~Renderer() override;
+
+  bool IsHeadless() const override;
+
+  bool Initialize() override;
+
+  std::unique_ptr<AbstractTexture> CreateTexture(const TextureConfig& config,
+                                                 std::string_view name) override;
+  std::unique_ptr<AbstractStagingTexture>
+  CreateStagingTexture(StagingTextureType type, const TextureConfig& config) override;
+  std::unique_ptr<AbstractFramebuffer>
+  CreateFramebuffer(AbstractTexture* color_attachment, AbstractTexture* depth_attachment) override;
+
+  std::unique_ptr<AbstractShader> CreateShaderFromSource(ShaderStage stage, std::string_view source,
+                                                         std::string_view name) override;
+  std::unique_ptr<AbstractShader> CreateShaderFromBinary(ShaderStage stage, const void* data,
+                                                         size_t length,
+                                                         std::string_view name) override;
+  std::unique_ptr<AbstractShader> CreateShaderFromMSL(ShaderStage stage, std::string msl,
+                                                      std::string_view glsl, std::string_view name);
+  std::unique_ptr<NativeVertexFormat>
+  CreateNativeVertexFormat(const PortableVertexDeclaration& vtx_decl) override;
+  std::unique_ptr<AbstractPipeline> CreatePipeline(const AbstractPipelineConfig& config,
+                                                   const void* cache_data = nullptr,
+                                                   size_t cache_data_length = 0) override;
+
+  void Flush() override;
+  void WaitForGPUIdle() override;
+  void OnConfigChanged(u32 bits) override;
+
+  void ClearScreen(const MathUtil::Rectangle<int>& rc, bool color_enable, bool alpha_enable,
+                   bool z_enable, u32 color, u32 z) override;
+
+  void SetPipeline(const AbstractPipeline* pipeline) override;
+  void SetFramebuffer(AbstractFramebuffer* framebuffer) override;
+  void SetAndDiscardFramebuffer(AbstractFramebuffer* framebuffer) override;
+  void SetAndClearFramebuffer(AbstractFramebuffer* framebuffer, const ClearColor& color_value = {},
+                              float depth_value = 0.0f) override;
+  void SetScissorRect(const MathUtil::Rectangle<int>& rc) override;
+  void SetTexture(u32 index, const AbstractTexture* texture) override;
+  void SetSamplerState(u32 index, const SamplerState& state) override;
+  void SetComputeImageTexture(AbstractTexture* texture, bool read, bool write) override;
+  void UnbindTexture(const AbstractTexture* texture) override;
+  void SetViewport(float x, float y, float width, float height, float near_depth,
+                   float far_depth) override;
+  void Draw(u32 base_vertex, u32 num_vertices) override;
+  void DrawIndexed(u32 base_index, u32 num_indices, u32 base_vertex) override;
+  void DispatchComputeShader(const AbstractShader* shader, u32 groupsize_x, u32 groupsize_y,
+                             u32 groupsize_z, u32 groups_x, u32 groups_y, u32 groups_z) override;
+  void BindBackbuffer(const ClearColor& clear_color = {}) override;
+  void PresentBackbuffer() override;
+
+protected:
+  std::unique_ptr<::BoundingBox> CreateBoundingBox() const override;
+
+private:
+  MRCOwned<CAMetalLayer*> m_layer;
+  MRCOwned<id<CAMetalDrawable>> m_drawable;
+  std::unique_ptr<Texture> m_bb_texture;
+  std::unique_ptr<Framebuffer> m_backbuffer;
+  u32 m_texture_counter = 0;
+  u32 m_staging_texture_counter = 0;
+  std::array<u32, 4> m_shader_counter = {};
+  u32 m_pipeline_counter = 0;
+
+  void CheckForSurfaceChange();
+  void CheckForSurfaceResize();
+  void SetupSurface();
+};
+}  // namespace Metal

Source/Core/VideoBackends/Metal/MTLRenderer.mm

@@ -0,0 +1,709 @@
+// Copyright 2022 Dolphin Emulator Project
+// SPDX-License-Identifier: GPL-2.0-or-later
+
+#include "VideoBackends/Metal/MTLRenderer.h"
+
+#include "VideoBackends/Metal/MTLBoundingBox.h"
+#include "VideoBackends/Metal/MTLObjectCache.h"
+#include "VideoBackends/Metal/MTLPipeline.h"
+#include "VideoBackends/Metal/MTLStateTracker.h"
+#include "VideoBackends/Metal/MTLTexture.h"
+#include "VideoBackends/Metal/MTLUtil.h"
+#include "VideoBackends/Metal/MTLVertexManager.h"
+
+#include "VideoCommon/FramebufferManager.h"
+#include "VideoCommon/NativeVertexFormat.h"
+#include "VideoCommon/VertexShaderGen.h"
+#include "VideoCommon/VideoBackendBase.h"
+
+Metal::Renderer::Renderer(MRCOwned<CAMetalLayer*> layer, int width, int height, float layer_scale)
+    : ::Renderer(width, height, layer_scale, Util::ToAbstract([layer pixelFormat])),
+      m_layer(std::move(layer))
+{
+  UpdateActiveConfig();
+}
+
+Metal::Renderer::~Renderer() = default;
+
+bool Metal::Renderer::IsHeadless() const
+{
+  return m_layer == nullptr;
+}
+
+bool Metal::Renderer::Initialize()
+{
+  if (!::Renderer::Initialize())
+    return false;
+  SetupSurface();
+  g_state_tracker->FlushEncoders();
+  return true;
+}
+
+// MARK: Texture Creation
+
+std::unique_ptr<AbstractTexture> Metal::Renderer::CreateTexture(const TextureConfig& config,
+                                                                std::string_view name)
+{
+  @autoreleasepool
+  {
+    MRCOwned<MTLTextureDescriptor*> desc = MRCTransfer([MTLTextureDescriptor new]);
+    [desc setTextureType:config.samples > 1 ? MTLTextureType2DMultisampleArray :
+                                              MTLTextureType2DArray];
+    [desc setPixelFormat:Util::FromAbstract(config.format)];
+    [desc setWidth:config.width];
+    [desc setHeight:config.height];
+    [desc setMipmapLevelCount:config.levels];
+    [desc setArrayLength:config.layers];
+    [desc setSampleCount:config.samples];
+    [desc setStorageMode:MTLStorageModePrivate];
+    MTLTextureUsage usage = MTLTextureUsageShaderRead;
+    if (config.IsRenderTarget())
+      usage |= MTLTextureUsageRenderTarget;
+    if (config.IsComputeImage())
+      usage |= MTLTextureUsageShaderWrite;
+    [desc setUsage:usage];
+    id<MTLTexture> texture = [g_device newTextureWithDescriptor:desc];
+    if (!texture)
+      return nullptr;
+
+    if (name.empty())
+      [texture setLabel:[NSString stringWithFormat:@"Texture %d", m_texture_counter++]];
+    else
+      [texture setLabel:MRCTransfer([[NSString alloc] initWithBytes:name.data()
+                                                             length:name.size()
+                                                           encoding:NSUTF8StringEncoding])];
+    return std::make_unique<Texture>(MRCTransfer(texture), config);
+  }
+}
+
+std::unique_ptr<AbstractStagingTexture>
+Metal::Renderer::CreateStagingTexture(StagingTextureType type, const TextureConfig& config)
+{
+  @autoreleasepool
+  {
+    const size_t stride = config.GetStride();
+    const size_t buffer_size = stride * static_cast<size_t>(config.height);
+
+    MTLResourceOptions options = MTLStorageModeShared;
+    if (type == StagingTextureType::Upload)
+      options |= MTLResourceCPUCacheModeWriteCombined;
+
+    id<MTLBuffer> buffer = [g_device newBufferWithLength:buffer_size options:options];
+    if (!buffer)
+      return nullptr;
+    [buffer
+        setLabel:[NSString stringWithFormat:@"Staging Texture %d", m_staging_texture_counter++]];
+    return std::make_unique<StagingTexture>(MRCTransfer(buffer), type, config);
+  }
+}
+
+std::unique_ptr<AbstractFramebuffer>
+Metal::Renderer::CreateFramebuffer(AbstractTexture* color_attachment,
+                                   AbstractTexture* depth_attachment)
+{
+  AbstractTexture* const either_attachment = color_attachment ? color_attachment : depth_attachment;
+  return std::make_unique<Framebuffer>(
+      color_attachment, depth_attachment, either_attachment->GetWidth(),
+      either_attachment->GetHeight(), either_attachment->GetLayers(),
+      either_attachment->GetSamples());
+}
+
+// MARK: Pipeline Creation
+
+namespace Metal
+{
+class VertexFormat : public NativeVertexFormat
+{
+public:
+  VertexFormat(const PortableVertexDeclaration& vtx_decl)
+      : NativeVertexFormat(vtx_decl), m_desc(MRCTransfer([MTLVertexDescriptor new]))
+  {
+    [[[m_desc layouts] objectAtIndexedSubscript:0] setStride:vtx_decl.stride];
+    SetAttribute(SHADER_POSITION_ATTRIB, vtx_decl.position);
+    SetAttributes(SHADER_NORMAL_ATTRIB, vtx_decl.normals);
+    SetAttributes(SHADER_COLOR0_ATTRIB, vtx_decl.colors);
+    SetAttributes(SHADER_TEXTURE0_ATTRIB, vtx_decl.texcoords);
+    SetAttribute(SHADER_POSMTX_ATTRIB, vtx_decl.posmtx);
+  }
+
+  MTLVertexDescriptor* Get() const { return m_desc; }
+
+private:
+  template <size_t N>
+  void SetAttributes(u32 attribute, const AttributeFormat (&format)[N])
+  {
+    for (size_t i = 0; i < N; i++)
+      SetAttribute(attribute + i, format[i]);
+  }
+  void SetAttribute(u32 attribute, const AttributeFormat& format)
+  {
+    if (!format.enable)
+      return;
+    MTLVertexAttributeDescriptor* desc = [[m_desc attributes] objectAtIndexedSubscript:attribute];
+    [desc setFormat:ConvertFormat(format.type, format.components, format.integer)];
+    [desc setOffset:format.offset];
+    [desc setBufferIndex:0];
+  }
+
+  static MTLVertexFormat ConvertFormat(ComponentFormat format, int count, bool int_format)
+  {
+    static constexpr MTLVertexFormat formats[2][5][4] = {
+      [false] = {
+        [static_cast<int>(ComponentFormat::UByte)]  = { MTLVertexFormatUCharNormalized,  MTLVertexFormatUChar2Normalized,  MTLVertexFormatUChar3Normalized,  MTLVertexFormatUChar4Normalized  },
+        [static_cast<int>(ComponentFormat::Byte)]   = { MTLVertexFormatCharNormalized,   MTLVertexFormatChar2Normalized,   MTLVertexFormatChar3Normalized,   MTLVertexFormatChar4Normalized   },
+        [static_cast<int>(ComponentFormat::UShort)] = { MTLVertexFormatUShortNormalized, MTLVertexFormatUShort2Normalized, MTLVertexFormatUShort3Normalized, MTLVertexFormatUShort4Normalized },
+        [static_cast<int>(ComponentFormat::Short)]  = { MTLVertexFormatShortNormalized,  MTLVertexFormatShort2Normalized,  MTLVertexFormatShort3Normalized,  MTLVertexFormatShort4Normalized  },
+        [static_cast<int>(ComponentFormat::Float)]  = { MTLVertexFormatFloat,            MTLVertexFormatFloat2,            MTLVertexFormatFloat3,            MTLVertexFormatFloat4            },
+      },
+      [true] = {
+        [static_cast<int>(ComponentFormat::UByte)]  = { MTLVertexFormatUChar,  MTLVertexFormatUChar2,  MTLVertexFormatUChar3,  MTLVertexFormatUChar4  },
+        [static_cast<int>(ComponentFormat::Byte)]   = { MTLVertexFormatChar,   MTLVertexFormatChar2,   MTLVertexFormatChar3,   MTLVertexFormatChar4   },
+        [static_cast<int>(ComponentFormat::UShort)] = { MTLVertexFormatUShort, MTLVertexFormatUShort2, MTLVertexFormatUShort3, MTLVertexFormatUShort4 },
+        [static_cast<int>(ComponentFormat::Short)]  = { MTLVertexFormatShort,  MTLVertexFormatShort2,  MTLVertexFormatShort3,  MTLVertexFormatShort4  },
+        [static_cast<int>(ComponentFormat::Float)]  = { MTLVertexFormatFloat,  MTLVertexFormatFloat2,  MTLVertexFormatFloat3,  MTLVertexFormatFloat4  },
+      },
+    };
+    return formats[int_format][static_cast<int>(format)][count - 1];
+  }
+
+  MRCOwned<MTLVertexDescriptor*> m_desc;
+};
+}  // namespace Metal
+
+std::unique_ptr<AbstractShader> Metal::Renderer::CreateShaderFromSource(ShaderStage stage,
+                                                                        std::string_view source,
+                                                                        std::string_view name)
+{
+  std::optional<std::string> msl = Util::TranslateShaderToMSL(stage, source);
+  if (!msl.has_value())
+  {
+    PanicAlertFmt("Failed to convert shader {} to MSL", name);
+    return nullptr;
+  }
+
+  return CreateShaderFromMSL(stage, std::move(*msl), source, name);
+}
+
+std::unique_ptr<AbstractShader> Metal::Renderer::CreateShaderFromBinary(ShaderStage stage,
+                                                                        const void* data,
+                                                                        size_t length,
+                                                                        std::string_view name)
+{
+  return CreateShaderFromMSL(stage, std::string(static_cast<const char*>(data), length), {}, name);
+}
+
+// clang-format off
+
+static const char* StageFilename(ShaderStage stage)
+{
+  switch (stage)
+  {
+  case ShaderStage::Vertex:   return "vs";
+  case ShaderStage::Geometry: return "gs";
+  case ShaderStage::Pixel:    return "ps";
+  case ShaderStage::Compute:  return "cs";
+  }
+}
+
+static NSString* GenericShaderName(ShaderStage stage)
+{
+  switch (stage)
+  {
+  case ShaderStage::Vertex:   return @"Vertex shader %d";
+  case ShaderStage::Geometry: return @"Geometry shader %d";
+  case ShaderStage::Pixel:    return @"Pixel shader %d";
+  case ShaderStage::Compute:  return @"Compute shader %d";
+  }
+}
+
+// clang-format on
+
+std::unique_ptr<AbstractShader> Metal::Renderer::CreateShaderFromMSL(ShaderStage stage,
+                                                                     std::string msl,
+                                                                     std::string_view glsl,
+                                                                     std::string_view name)
+{
+  @autoreleasepool
+  {
+    NSError* err = nullptr;
+    auto DumpBadShader = [&](std::string_view msg) {
+      static int counter = 0;
+      std::string filename = VideoBackendBase::BadShaderFilename(StageFilename(stage), counter++);
+      std::ofstream stream(filename);
+      if (stream.good())
+      {
+        stream << msl << std::endl;
+        stream << "/*" << std::endl;
+        stream << msg << std::endl;
+        stream << "Error:" << std::endl;
+        stream << [[err localizedDescription] UTF8String] << std::endl;
+        if (!glsl.empty())
+        {
+          stream << "Original GLSL:" << std::endl;
+          stream << glsl << std::endl;
+        }
+        else
+        {
+          stream << "Shader was created with cached MSL so no GLSL is available." << std::endl;
+        }
+      }
+
+      stream << std::endl;
+      stream << "Dolphin Version: " << Common::GetScmRevStr() << std::endl;
+      stream << "Video Backend: " << g_video_backend->GetDisplayName() << std::endl;
+      stream << "*/" << std::endl;
+      stream.close();
+
+      PanicAlertFmt("{} (written to {})\n", msg, filename);
+    };
+
+    auto lib = MRCTransfer([g_device newLibraryWithSource:[NSString stringWithUTF8String:msl.data()]
+                                                  options:nil
+                                                    error:&err]);
+    if (err)
+    {
+      DumpBadShader(fmt::format("Failed to compile {}", name));
+      return nullptr;
+    }
+    auto fn = MRCTransfer([lib newFunctionWithName:@"main0"]);
+    if (!fn)
+    {
+      DumpBadShader(fmt::format("Shader {} is missing its main0 function", name));
+      return nullptr;
+    }
+    if (!name.empty())
+      [fn setLabel:MRCTransfer([[NSString alloc] initWithBytes:name.data()
+                                                        length:name.size()
+                                                      encoding:NSUTF8StringEncoding])];
+    else
+      [fn setLabel:[NSString stringWithFormat:GenericShaderName(stage),
+                                              m_shader_counter[static_cast<u32>(stage)]++]];
+    [lib setLabel:[fn label]];
+    if (stage == ShaderStage::Compute)
+    {
+      MTLComputePipelineReflection* reflection = nullptr;
+      auto desc = [MTLComputePipelineDescriptor new];
+      [desc setComputeFunction:fn];
+      [desc setLabel:[fn label]];
+      MRCOwned<id<MTLComputePipelineState>> pipeline =
+          MRCTransfer([g_device newComputePipelineStateWithDescriptor:desc
+                                                              options:MTLPipelineOptionArgumentInfo
+                                                           reflection:&reflection
+                                                                error:&err]);
+      if (err)
+      {
+        DumpBadShader(fmt::format("Failed to compile compute pipeline {}", name));
+        return nullptr;
+      }
+      return std::make_unique<ComputePipeline>(stage, reflection, std::move(msl), std::move(fn),
+                                               std::move(pipeline));
+    }
+    return std::make_unique<Shader>(stage, std::move(msl), std::move(fn));
+  }
+}
+
+std::unique_ptr<NativeVertexFormat>
+Metal::Renderer::CreateNativeVertexFormat(const PortableVertexDeclaration& vtx_decl)
+{
+  @autoreleasepool
+  {
+    return std::make_unique<VertexFormat>(vtx_decl);
+  }
+}
+
+static MTLPrimitiveTopologyClass GetClass(PrimitiveType prim)
+{
+  switch (prim)
+  {
+  case PrimitiveType::Points:
+    return MTLPrimitiveTopologyClassPoint;
+  case PrimitiveType::Lines:
+    return MTLPrimitiveTopologyClassLine;
+  case PrimitiveType::Triangles:
+  case PrimitiveType::TriangleStrip:
+    return MTLPrimitiveTopologyClassTriangle;
+  }
+}
+
+static MTLPrimitiveType Convert(PrimitiveType prim)
+{
+  switch (prim)
+  {
+    case PrimitiveType::Points:        return MTLPrimitiveTypePoint;
+    case PrimitiveType::Lines:         return MTLPrimitiveTypeLine;
+    case PrimitiveType::Triangles:     return MTLPrimitiveTypeTriangle;
+    case PrimitiveType::TriangleStrip: return MTLPrimitiveTypeTriangleStrip;
+  }
+}
+
+static MTLCullMode Convert(CullMode cull)
+{
+  switch (cull)
+  {
+    case CullMode::None:
+    case CullMode::All: // Handled by disabling rasterization
+      return MTLCullModeNone;
+    case CullMode::Front:
+      return MTLCullModeFront;
+    case CullMode::Back:
+      return MTLCullModeBack;
+  }
+}
+
+static MTLBlendFactor Convert(DstBlendFactor factor, bool src1)
+{
+  static constexpr MTLBlendFactor factors[2][8] = {
+    [false] = {
+      [static_cast<int>(DstBlendFactor::Zero)]        = MTLBlendFactorZero,
+      [static_cast<int>(DstBlendFactor::One)]         = MTLBlendFactorOne,
+      [static_cast<int>(DstBlendFactor::SrcClr)]      = MTLBlendFactorSourceColor,
+      [static_cast<int>(DstBlendFactor::InvSrcClr)]   = MTLBlendFactorOneMinusSourceColor,
+      [static_cast<int>(DstBlendFactor::SrcAlpha)]    = MTLBlendFactorSourceAlpha,
+      [static_cast<int>(DstBlendFactor::InvSrcAlpha)] = MTLBlendFactorOneMinusSourceAlpha,
+      [static_cast<int>(DstBlendFactor::DstAlpha)]    = MTLBlendFactorDestinationAlpha,
+      [static_cast<int>(DstBlendFactor::InvDstAlpha)] = MTLBlendFactorOneMinusDestinationAlpha,
+    },
+    [true] = {
+      [static_cast<int>(DstBlendFactor::Zero)]        = MTLBlendFactorZero,
+      [static_cast<int>(DstBlendFactor::One)]         = MTLBlendFactorOne,
+      [static_cast<int>(DstBlendFactor::SrcClr)]      = MTLBlendFactorSourceColor,
+      [static_cast<int>(DstBlendFactor::InvSrcClr)]   = MTLBlendFactorOneMinusSource1Color,
+      [static_cast<int>(DstBlendFactor::SrcAlpha)]    = MTLBlendFactorSource1Alpha,
+      [static_cast<int>(DstBlendFactor::InvSrcAlpha)] = MTLBlendFactorOneMinusSource1Alpha,
+      [static_cast<int>(DstBlendFactor::DstAlpha)]    = MTLBlendFactorDestinationAlpha,
+      [static_cast<int>(DstBlendFactor::InvDstAlpha)] = MTLBlendFactorOneMinusDestinationAlpha,
+    },
+  };
+  return factors[src1][static_cast<int>(factor)];
+}
+
+static MTLBlendFactor Convert(SrcBlendFactor factor, bool src1)
+{
+  static constexpr MTLBlendFactor factors[2][8] = {
+    [false] = {
+      [static_cast<int>(SrcBlendFactor::Zero)]        = MTLBlendFactorZero,
+      [static_cast<int>(SrcBlendFactor::One)]         = MTLBlendFactorOne,
+      [static_cast<int>(SrcBlendFactor::DstClr)]      = MTLBlendFactorDestinationColor,
+      [static_cast<int>(SrcBlendFactor::InvDstClr)]   = MTLBlendFactorOneMinusDestinationColor,
+      [static_cast<int>(SrcBlendFactor::SrcAlpha)]    = MTLBlendFactorSourceAlpha,
+      [static_cast<int>(SrcBlendFactor::InvSrcAlpha)] = MTLBlendFactorOneMinusSourceAlpha,
+      [static_cast<int>(SrcBlendFactor::DstAlpha)]    = MTLBlendFactorDestinationAlpha,
+      [static_cast<int>(SrcBlendFactor::InvDstAlpha)] = MTLBlendFactorOneMinusDestinationAlpha,
+    },
+    [true] = {
+      [static_cast<int>(SrcBlendFactor::Zero)]        = MTLBlendFactorZero,
+      [static_cast<int>(SrcBlendFactor::One)]         = MTLBlendFactorOne,
+      [static_cast<int>(SrcBlendFactor::DstClr)]      = MTLBlendFactorDestinationColor,
+      [static_cast<int>(SrcBlendFactor::InvDstClr)]   = MTLBlendFactorOneMinusDestinationColor,
+      [static_cast<int>(SrcBlendFactor::SrcAlpha)]    = MTLBlendFactorSource1Alpha,
+      [static_cast<int>(SrcBlendFactor::InvSrcAlpha)] = MTLBlendFactorOneMinusSource1Alpha,
+      [static_cast<int>(SrcBlendFactor::DstAlpha)]    = MTLBlendFactorDestinationAlpha,
+      [static_cast<int>(SrcBlendFactor::InvDstAlpha)] = MTLBlendFactorOneMinusDestinationAlpha,
+    },
+  };
+  return factors[src1][static_cast<int>(factor)];
+}
+
+std::unique_ptr<AbstractPipeline>
+Metal::Renderer::CreatePipeline(const AbstractPipelineConfig& config, const void* cache_data,
+                                size_t cache_data_length)
+{
+  @autoreleasepool
+  {
+    assert(!config.geometry_shader);
+    auto desc = MRCTransfer([MTLRenderPipelineDescriptor new]);
+    [desc setLabel:[NSString stringWithFormat:@"Pipeline %d", m_pipeline_counter++]];
+    [desc setVertexFunction:static_cast<const Shader*>(config.vertex_shader)->GetShader()];
+    [desc setFragmentFunction:static_cast<const Shader*>(config.pixel_shader)->GetShader()];
+    if (config.vertex_format)
+      [desc setVertexDescriptor:static_cast<const VertexFormat*>(config.vertex_format)->Get()];
+    RasterizationState rs = config.rasterization_state;
+    [desc setInputPrimitiveTopology:GetClass(rs.primitive)];
+    if (rs.cullmode == CullMode::All)
+      [desc setRasterizationEnabled:NO];
+    MTLRenderPipelineColorAttachmentDescriptor* color0 = [desc colorAttachments][0];
+    BlendingState bs = config.blending_state;
+    MTLColorWriteMask mask = MTLColorWriteMaskNone;
+    if (bs.colorupdate)
+      mask |= MTLColorWriteMaskRed | MTLColorWriteMaskGreen | MTLColorWriteMaskBlue;
+    if (bs.alphaupdate)
+      mask |= MTLColorWriteMaskAlpha;
+    [color0 setWriteMask:mask];
+    if (bs.blendenable)
+    {
+      [color0 setBlendingEnabled:YES];
+      [color0 setSourceRGBBlendFactor:       Convert(bs.srcfactor,      bs.usedualsrc)];
+      [color0 setSourceAlphaBlendFactor:     Convert(bs.srcfactoralpha, bs.usedualsrc)];
+      [color0 setDestinationRGBBlendFactor:  Convert(bs.dstfactor,      bs.usedualsrc)];
+      [color0 setDestinationAlphaBlendFactor:Convert(bs.dstfactoralpha, bs.usedualsrc)];
+      [color0 setRgbBlendOperation:  bs.subtract      ? MTLBlendOperationReverseSubtract : MTLBlendOperationAdd];
+      [color0 setAlphaBlendOperation:bs.subtractAlpha ? MTLBlendOperationReverseSubtract : MTLBlendOperationAdd];
+    }
+    FramebufferState fs = config.framebuffer_state;
+    [color0 setPixelFormat:Util::FromAbstract(fs.color_texture_format)];
+    [desc setDepthAttachmentPixelFormat:Util::FromAbstract(fs.depth_texture_format)];
+    if (Util::HasStencil(fs.depth_texture_format))
+      [desc setStencilAttachmentPixelFormat:Util::FromAbstract(fs.depth_texture_format)];
+    NSError* err = nullptr;
+    MTLRenderPipelineReflection* reflection = nullptr;
+    id<MTLRenderPipelineState> pipe =
+        [g_device newRenderPipelineStateWithDescriptor:desc
+                                               options:MTLPipelineOptionArgumentInfo
+                                            reflection:&reflection
+                                                 error:&err];
+    if (err)
+    {
+      PanicAlertFmt("Failed to compile pipeline for {} and {}: {}",
+                    [[[desc vertexFunction] label] UTF8String],
+                    [[[desc fragmentFunction] label] UTF8String],
+                    [[err localizedDescription] UTF8String]);
+      return nullptr;
+    }
+    return std::make_unique<Pipeline>(MRCTransfer(pipe), reflection, Convert(rs.primitive),
+                                      Convert(rs.cullmode), config.depth_state, config.usage);
+  }
+}
+
+void Metal::Renderer::Flush()
+{
+  @autoreleasepool
+  {
+    g_state_tracker->FlushEncoders();
+  }
+}
+
+void Metal::Renderer::WaitForGPUIdle()
+{
+  @autoreleasepool
+  {
+    g_state_tracker->FlushEncoders();
+    g_state_tracker->WaitForFlushedEncoders();
+  }
+}
+
+void Metal::Renderer::OnConfigChanged(u32 bits)
+{
+  if (bits & CONFIG_CHANGE_BIT_VSYNC)
+    [m_layer setDisplaySyncEnabled:g_ActiveConfig.bVSyncActive];
+
+  if (bits & CONFIG_CHANGE_BIT_ANISOTROPY)
+  {
+    g_object_cache->ReloadSamplers();
+    g_state_tracker->ReloadSamplers();
+  }
+}
+
+void Metal::Renderer::ClearScreen(const MathUtil::Rectangle<int>& rc, bool color_enable,
+                                  bool alpha_enable, bool z_enable, u32 color, u32 z)
+{
+  MathUtil::Rectangle<int> target_rc = Renderer::ConvertEFBRectangle(rc);
+  target_rc.ClampUL(0, 0, m_target_width, m_target_height);
+
+  // All Metal render passes are fullscreen, so we can only run a fast clear if the target is too
+  if (target_rc == MathUtil::Rectangle<int>(0, 0, m_target_width, m_target_height))
+  {
+    // Determine whether the EFB has an alpha channel. If it doesn't, we can clear the alpha
+    // channel to 0xFF. This hopefully allows us to use the fast path in most cases.
+    if (bpmem.zcontrol.pixel_format == PixelFormat::RGB565_Z16 ||
+        bpmem.zcontrol.pixel_format == PixelFormat::RGB8_Z24 ||
+        bpmem.zcontrol.pixel_format == PixelFormat::Z24)
+    {
+      // Force alpha writes, and clear the alpha channel. This is different to the other backends,
+      // where the existing values of the alpha channel are preserved.
+      alpha_enable = true;
+      color &= 0x00FFFFFF;
+    }
+
+    bool c_ok = (color_enable && alpha_enable) ||
+                g_state_tracker->GetCurrentFramebuffer()->GetColorFormat() ==
+                    AbstractTextureFormat::Undefined;
+    bool z_ok = z_enable || g_state_tracker->GetCurrentFramebuffer()->GetDepthFormat() ==
+                                AbstractTextureFormat::Undefined;
+    if (c_ok && z_ok)
+    {
+      @autoreleasepool
+      {
+        // clang-format off
+        MTLClearColor clear_color = MTLClearColorMake(
+            static_cast<double>((color >> 16) & 0xFF) / 255.0,
+            static_cast<double>((color >>  8) & 0xFF) / 255.0,
+            static_cast<double>((color >>  0) & 0xFF) / 255.0,
+            static_cast<double>((color >> 24) & 0xFF) / 255.0);
+        // clang-format on
+        float z_normalized = static_cast<float>(z & 0xFFFFFF) / 16777216.0f;
+        if (!g_Config.backend_info.bSupportsReversedDepthRange)
+          z_normalized = 1.f - z_normalized;
+        g_state_tracker->BeginClearRenderPass(clear_color, z_normalized);
+        return;
+      }
+    }
+  }
+
+  g_state_tracker->EnableEncoderLabel(false);
+  g_framebuffer_manager->ClearEFB(rc, color_enable, alpha_enable, z_enable, color, z);
+  g_state_tracker->EnableEncoderLabel(true);
+}
+
+void Metal::Renderer::SetPipeline(const AbstractPipeline* pipeline)
+{
+  g_state_tracker->SetPipeline(static_cast<const Pipeline*>(pipeline));
+}
+
+void Metal::Renderer::SetFramebuffer(AbstractFramebuffer* framebuffer)
+{
+  // Shouldn't be bound as a texture.
+  if (AbstractTexture* color = framebuffer->GetColorAttachment())
+    g_state_tracker->UnbindTexture(static_cast<Texture*>(color)->GetMTLTexture());
+  if (AbstractTexture* depth = framebuffer->GetDepthAttachment())
+    g_state_tracker->UnbindTexture(static_cast<Texture*>(depth)->GetMTLTexture());
+
+  m_current_framebuffer = framebuffer;
+  g_state_tracker->SetCurrentFramebuffer(static_cast<Framebuffer*>(framebuffer));
+}
+
+void Metal::Renderer::SetAndDiscardFramebuffer(AbstractFramebuffer* framebuffer)
+{
+  @autoreleasepool
+  {
+    SetFramebuffer(framebuffer);
+    g_state_tracker->BeginRenderPass(MTLLoadActionDontCare);
+  }
+}
+
+void Metal::Renderer::SetAndClearFramebuffer(AbstractFramebuffer* framebuffer,
+                                             const ClearColor& color_value, float depth_value)
+{
+  @autoreleasepool
+  {
+    SetFramebuffer(framebuffer);
+    MTLClearColor color =
+        MTLClearColorMake(color_value[0], color_value[1], color_value[2], color_value[3]);
+    g_state_tracker->BeginClearRenderPass(color, depth_value);
+  }
+}
+
+void Metal::Renderer::SetScissorRect(const MathUtil::Rectangle<int>& rc)
+{
+  g_state_tracker->SetScissor(rc);
+}
+
+void Metal::Renderer::SetTexture(u32 index, const AbstractTexture* texture)
+{
+  g_state_tracker->SetTexture(
+      index, texture ? static_cast<const Texture*>(texture)->GetMTLTexture() : nullptr);
+}
+
+void Metal::Renderer::SetSamplerState(u32 index, const SamplerState& state)
+{
+  g_state_tracker->SetSampler(index, state);
+}
+
+void Metal::Renderer::SetComputeImageTexture(AbstractTexture* texture, bool read, bool write)
+{
+  g_state_tracker->SetComputeTexture(static_cast<const Texture*>(texture));
+}
+
+void Metal::Renderer::UnbindTexture(const AbstractTexture* texture)
+{
+  g_state_tracker->UnbindTexture(static_cast<const Texture*>(texture)->GetMTLTexture());
+}
+
+void Metal::Renderer::SetViewport(float x, float y, float width, float height, float near_depth,
+                                  float far_depth)
+{
+  g_state_tracker->SetViewport(x, y, width, height, near_depth, far_depth);
+}
+
+void Metal::Renderer::Draw(u32 base_vertex, u32 num_vertices)
+{
+  @autoreleasepool
+  {
+    g_state_tracker->Draw(base_vertex, num_vertices);
+  }
+}
+
+void Metal::Renderer::DrawIndexed(u32 base_index, u32 num_indices, u32 base_vertex)
+{
+  @autoreleasepool
+  {
+    g_state_tracker->DrawIndexed(base_index, num_indices, base_vertex);
+  }
+}
+
+void Metal::Renderer::DispatchComputeShader(const AbstractShader* shader,  //
+                                            u32 groupsize_x, u32 groupsize_y, u32 groupsize_z,
+                                            u32 groups_x, u32 groups_y, u32 groups_z)
+{
+  @autoreleasepool
+  {
+    g_state_tracker->SetPipeline(static_cast<const ComputePipeline*>(shader));
+    g_state_tracker->DispatchComputeShader(groupsize_x, groupsize_y, groupsize_z,  //
+                                           groups_x, groups_y, groups_z);
+  }
+}
+
+void Metal::Renderer::BindBackbuffer(const ClearColor& clear_color)
+{
+  @autoreleasepool
+  {
+    CheckForSurfaceChange();
+    CheckForSurfaceResize();
+    m_drawable = MRCRetain([m_layer nextDrawable]);
+    m_bb_texture->SetMTLTexture(MRCRetain([m_drawable texture]));
+    SetAndClearFramebuffer(m_backbuffer.get(), clear_color);
+  }
+}
+
+void Metal::Renderer::PresentBackbuffer()
+{
+  @autoreleasepool
+  {
+    g_state_tracker->EndRenderPass();
+    if (m_drawable)
+    {
+      [g_state_tracker->GetRenderCmdBuf()
+          addScheduledHandler:[drawable = std::move(m_drawable)](id) { [drawable present]; }];
+      m_bb_texture->SetMTLTexture(nullptr);
+      m_drawable = nullptr;
+    }
+    g_state_tracker->FlushEncoders();
+  }
+}
+
+std::unique_ptr<::BoundingBox> Metal::Renderer::CreateBoundingBox() const
+{
+  return std::make_unique<BoundingBox>();
+}
+
+void Metal::Renderer::CheckForSurfaceChange()
+{
+  if (!m_surface_changed.TestAndClear())
+    return;
+  m_layer = MRCRetain(static_cast<CAMetalLayer*>(m_new_surface_handle));
+  m_new_surface_handle = nullptr;
+  SetupSurface();
+}
+
+void Metal::Renderer::CheckForSurfaceResize()
+{
+  if (!m_surface_resized.TestAndClear())
+    return;
+  SetupSurface();
+}
+
+void Metal::Renderer::SetupSurface()
+{
+  CGSize size = [m_layer bounds].size;
+  // TODO: Update m_backbuffer_scale (need to make doing that not break everything)
+  const float backbuffer_scale = [m_layer contentsScale];
+  size.width *= backbuffer_scale;
+  size.height *= backbuffer_scale;
+  [m_layer setDrawableSize:size];
+  m_backbuffer_width = size.width;
+  m_backbuffer_height = size.height;
+  TextureConfig cfg(m_backbuffer_width, m_backbuffer_height, 1, 1, 1, m_backbuffer_format,
+                    AbstractTextureFlag_RenderTarget);
+  m_bb_texture = std::make_unique<Texture>(nullptr, cfg);
+  m_backbuffer = std::make_unique<Framebuffer>(m_bb_texture.get(), nullptr,  //
+                                               m_backbuffer_width, m_backbuffer_height, 1, 1);
+}

Source/Core/VideoBackends/Metal/MTLShader.h

@@ -0,0 +1,30 @@
+// Copyright 2022 Dolphin Emulator Project
+// SPDX-License-Identifier: GPL-2.0-or-later
+
+#pragma once
+
+#include <Metal/Metal.h>
+
+#include "VideoBackends/Metal/MRCHelpers.h"
+
+#include "VideoCommon/AbstractPipeline.h"
+#include "VideoCommon/AbstractShader.h"
+
+namespace Metal
+{
+class Shader : public AbstractShader
+{
+public:
+  explicit Shader(ShaderStage stage, std::string msl, MRCOwned<id<MTLFunction>> shader)
+      : AbstractShader(stage), m_msl(std::move(msl)), m_shader(std::move(shader))
+  {
+  }
+
+  id<MTLFunction> GetShader() const { return m_shader; }
+  BinaryData GetBinary() const override { return BinaryData(m_msl.begin(), m_msl.end()); }
+
+private:
+  std::string m_msl;
+  MRCOwned<id<MTLFunction>> m_shader;
+};
+}  // namespace Metal

Source/Core/VideoBackends/Metal/MTLStateTracker.h

@@ -0,0 +1,266 @@
+// Copyright 2022 Dolphin Emulator Project
+// SPDX-License-Identifier: GPL-2.0-or-later
+
+#pragma once
+
+#include <Metal/Metal.h>
+#include <atomic>
+#include <memory>
+#include <vector>
+
+#include "Common/Assert.h"
+#include "Common/CommonTypes.h"
+#include "Common/MathUtil.h"
+
+#include "VideoBackends/Metal/MRCHelpers.h"
+#include "VideoBackends/Metal/MTLObjectCache.h"
+#include "VideoBackends/Metal/MTLTexture.h"
+#include "VideoBackends/Metal/MTLUtil.h"
+
+#include "VideoCommon/RenderBase.h"
+
+namespace Metal
+{
+class Pipeline;
+class ComputePipeline;
+
+class StateTracker
+{
+public:
+  enum class UploadBuffer
+  {
+    Other,
+    Uniform,
+    Vertex,
+    Index,
+    Texels,
+    Last = Texels
+  };
+
+  struct Map
+  {
+    id<MTLBuffer> gpu_buffer;
+    size_t gpu_offset;
+    void* cpu_buffer;
+  };
+
+  enum class AlignMask : size_t
+  {
+    Other = 15,
+    Uniform = 255,
+  };
+
+  StateTracker(StateTracker&&) = delete;
+  explicit StateTracker();
+  ~StateTracker();
+
+  Framebuffer* GetCurrentFramebuffer() { return m_current_framebuffer; };
+  void SetCurrentFramebuffer(Framebuffer* framebuffer);
+  void BeginClearRenderPass(MTLClearColor color, float depth);
+  void BeginRenderPass(MTLLoadAction load_action);
+  void BeginRenderPass(MTLRenderPassDescriptor* descriptor);
+  void BeginComputePass();
+  MTLRenderPassDescriptor* GetRenderPassDescriptor(Framebuffer* framebuffer,
+                                                   MTLLoadAction load_action);
+
+  void EndRenderPass();
+  void FlushEncoders();
+  void WaitForFlushedEncoders();
+  bool HasUnflushedData() { return static_cast<bool>(m_current_render_cmdbuf); }
+  bool GPUBusy()
+  {
+    return m_current_draw != 1 + m_last_finished_draw.load(std::memory_order_acquire);
+  }
+  void ReloadSamplers();
+
+  void SetPipeline(const Pipeline* pipe);
+  void SetPipeline(const ComputePipeline* pipe);
+  void SetScissor(const MathUtil::Rectangle<int>& rect);
+  void SetViewport(float x, float y, float width, float height, float near_depth, float far_depth);
+  void SetTexture(u32 idx, id<MTLTexture> texture);
+  void SetSampler(u32 idx, const SamplerState& sampler);
+  void SetComputeTexture(const Texture* texture);
+  void InvalidateUniforms(bool vertex, bool fragment);
+  void SetUtilityUniform(const void* buffer, size_t size);
+  void SetTexelBuffer(id<MTLBuffer> buffer, u32 offset0, u32 offset1);
+  void SetVerticesAndIndices(Map vertices, Map indices);
+  void SetBBoxBuffer(id<MTLBuffer> bbox, id<MTLFence> upload, id<MTLFence> download);
+  void SetVertexBufferNow(u32 idx, id<MTLBuffer> buffer, u32 offset);
+  void SetFragmentBufferNow(u32 idx, id<MTLBuffer> buffer, u32 offset);
+  /// Use around utility draws that are commonly used immediately before gx draws to the same buffer
+  void EnableEncoderLabel(bool enabled) { m_flags.should_apply_label = enabled; }
+  void UnbindTexture(id<MTLTexture> texture);
+
+  void Draw(u32 base_vertex, u32 num_vertices);
+  void DrawIndexed(u32 base_index, u32 num_indices, u32 base_vertex);
+  void DispatchComputeShader(u32 groupsize_x, u32 groupsize_y, u32 groupsize_z, u32 groups_x,
+                             u32 groups_y, u32 groups_z);
+  void ResolveTexture(id<MTLTexture> src, id<MTLTexture> dst, u32 layer, u32 level);
+
+  size_t Align(size_t amt, AlignMask align)
+  {
+    return (amt + static_cast<size_t>(align)) & ~static_cast<size_t>(align);
+  }
+  Map AllocateForTextureUpload(size_t amt);
+  Map Allocate(UploadBuffer buffer_idx, size_t amt, AlignMask align)
+  {
+    Preallocate(buffer_idx, amt);
+    return CommitPreallocation(buffer_idx, amt, align);
+  }
+  void* Preallocate(UploadBuffer buffer_idx, size_t amt);
+  /// Must follow a call to Preallocate where amt is >= to the one provided here
+  Map CommitPreallocation(UploadBuffer buffer_idx, size_t amt, AlignMask align)
+  {
+    DEBUG_ASSERT((m_upload_buffers[static_cast<int>(buffer_idx)].usage.Pos() &
+                  static_cast<size_t>(align)) == 0);
+    return CommitPreallocation(buffer_idx, Align(amt, align));
+  }
+  id<MTLBlitCommandEncoder> GetUploadEncoder();
+  id<MTLBlitCommandEncoder> GetTextureUploadEncoder();
+  id<MTLCommandBuffer> GetRenderCmdBuf();
+
+private:
+  class UsageTracker
+  {
+    struct UsageEntry
+    {
+      u64 drawno;
+      size_t pos;
+    };
+    std::vector<UsageEntry> m_usage;
+    size_t m_size = 0;
+    size_t m_pos = 0;
+
+  public:
+    size_t Size() { return m_size; }
+    size_t Pos() { return m_pos; }
+    bool PrepareForAllocation(u64 last_draw, size_t amt);
+    size_t Allocate(u64 current_draw, size_t amt);
+    void Reset(size_t new_size);
+  };
+
+  struct CPUBuffer
+  {
+    UsageTracker usage;
+    MRCOwned<id<MTLBuffer>> mtlbuffer;
+    void* buffer = nullptr;
+  };
+
+  struct BufferPair
+  {
+    UsageTracker usage;
+    MRCOwned<id<MTLBuffer>> cpubuffer;
+    MRCOwned<id<MTLBuffer>> gpubuffer;
+    void* buffer = nullptr;
+    size_t last_upload = 0;
+  };
+
+  struct Backref;
+
+  std::shared_ptr<Backref> m_backref;
+  MRCOwned<id<MTLFence>> m_fence;
+  MRCOwned<id<MTLCommandBuffer>> m_upload_cmdbuf;
+  MRCOwned<id<MTLBlitCommandEncoder>> m_upload_encoder;
+  MRCOwned<id<MTLCommandBuffer>> m_texture_upload_cmdbuf;
+  MRCOwned<id<MTLBlitCommandEncoder>> m_texture_upload_encoder;
+  MRCOwned<id<MTLCommandBuffer>> m_current_render_cmdbuf;
+  MRCOwned<id<MTLCommandBuffer>> m_last_render_cmdbuf;
+  MRCOwned<id<MTLRenderCommandEncoder>> m_current_render_encoder;
+  MRCOwned<id<MTLComputeCommandEncoder>> m_current_compute_encoder;
+  MRCOwned<MTLRenderPassDescriptor*> m_render_pass_desc[3];
+  MRCOwned<MTLRenderPassDescriptor*> m_resolve_pass_desc;
+  Framebuffer* m_current_framebuffer;
+  CPUBuffer m_texture_upload_buffer;
+  BufferPair m_upload_buffers[static_cast<int>(UploadBuffer::Last) + 1];
+  u64 m_current_draw = 1;
+  std::atomic<u64> m_last_finished_draw{0};
+
+  MRCOwned<id<MTLTexture>> m_dummy_texture;
+
+  // MARK: State
+  u8 m_dirty_textures;
+  u8 m_dirty_samplers;
+  union Flags
+  {
+    struct
+    {
+      // clang-format off
+      bool has_gx_vs_uniform      : 1;
+      bool has_gx_ps_uniform      : 1;
+      bool has_utility_vs_uniform : 1;
+      bool has_utility_ps_uniform : 1;
+      bool has_compute_texture    : 1;
+      bool has_pipeline           : 1;
+      bool has_scissor            : 1;
+      bool has_viewport           : 1;
+      bool has_vertices           : 1;
+      bool has_texel_buffer       : 1;
+      bool bbox_fence             : 1;
+      bool should_apply_label     : 1;
+      // clang-format on
+    };
+    u16 bits = 0;
+    void NewEncoder()
+    {
+      Flags reset_mask;
+      // Set the flags you *don't* want to reset
+      reset_mask.should_apply_label = true;
+      bits &= reset_mask.bits;
+    }
+  } m_flags;
+
+  /// Things that represent the state of the encoder
+  struct Current
+  {
+    NSString* label;
+    id<MTLRenderPipelineState> pipeline;
+    std::array<id<MTLBuffer>, 2> vertex_buffers;
+    std::array<id<MTLBuffer>, 2> fragment_buffers;
+    u32 width;
+    u32 height;
+    MathUtil::Rectangle<int> scissor_rect;
+    Util::Viewport viewport;
+    MTLDepthClipMode depth_clip_mode;
+    MTLCullMode cull_mode;
+    DepthStencilSelector depth_stencil;
+  } m_current;
+
+  /// Things that represent what we'd *like* to have on the encoder for the next draw
+  struct State
+  {
+    MathUtil::Rectangle<int> scissor_rect;
+    Util::Viewport viewport;
+    const Pipeline* render_pipeline = nullptr;
+    const ComputePipeline* compute_pipeline = nullptr;
+    std::array<id<MTLTexture>, 8> textures = {};
+    std::array<id<MTLSamplerState>, 8> samplers = {};
+    std::array<float, 8> sampler_min_lod;
+    std::array<float, 8> sampler_max_lod;
+    std::array<SamplerState, 8> sampler_states;
+    const Texture* compute_texture = nullptr;
+    std::unique_ptr<u8[]> utility_uniform;
+    u32 utility_uniform_size = 0;
+    u32 utility_uniform_capacity = 0;
+    id<MTLBuffer> bbox = nullptr;
+    id<MTLFence> bbox_upload_fence = nullptr;
+    id<MTLFence> bbox_download_fence = nullptr;
+    id<MTLBuffer> vertices = nullptr;
+    id<MTLBuffer> indices = nullptr;
+    id<MTLBuffer> texels = nullptr;
+    u32 vertices_offset;
+    u32 indices_offset;
+    u32 texel_buffer_offset0;
+    u32 texel_buffer_offset1;
+  } m_state;
+
+  void SetSamplerForce(u32 idx, const SamplerState& sampler);
+  void Sync(BufferPair& buffer);
+  Map CommitPreallocation(UploadBuffer buffer_idx, size_t actual_amt);
+  void CheckViewport();
+  void CheckScissor();
+  void PrepareRender();
+  void PrepareCompute();
+};
+
+extern std::unique_ptr<StateTracker> g_state_tracker;
+}  // namespace Metal

Source/Core/VideoBackends/Metal/MTLStateTracker.mm

@@ -0,0 +1,849 @@
+// Copyright 2022 Dolphin Emulator Project
+// SPDX-License-Identifier: GPL-2.0-or-later
+
+#include "VideoBackends/Metal/MTLStateTracker.h"
+
+#include <algorithm>
+#include <mutex>
+
+#include "Common/Assert.h"
+#include "Common/BitUtils.h"
+
+#include "VideoBackends/Metal/MTLObjectCache.h"
+#include "VideoBackends/Metal/MTLPipeline.h"
+#include "VideoBackends/Metal/MTLTexture.h"
+#include "VideoBackends/Metal/MTLUtil.h"
+
+#include "VideoCommon/PixelShaderManager.h"
+#include "VideoCommon/Statistics.h"
+#include "VideoCommon/VertexShaderManager.h"
+#include "VideoCommon/VideoConfig.h"
+
+std::unique_ptr<Metal::StateTracker> Metal::g_state_tracker;
+
+struct Metal::StateTracker::Backref
+{
+  std::mutex mtx;
+  StateTracker* state_tracker;
+  explicit Backref(StateTracker* state_tracker) : state_tracker(state_tracker) {}
+};
+
+static NSString* GetName(Metal::StateTracker::UploadBuffer buffer)
+{
+  // clang-format off
+  switch (buffer)
+  {
+    case Metal::StateTracker::UploadBuffer::Texels:  return @"Texels";
+    case Metal::StateTracker::UploadBuffer::Vertex:  return @"Vertices";
+    case Metal::StateTracker::UploadBuffer::Index:   return @"Indices";
+    case Metal::StateTracker::UploadBuffer::Uniform: return @"Uniforms";
+    case Metal::StateTracker::UploadBuffer::Other:   return @"Generic Upload";
+  }
+  // clang-format on
+}
+
+// MARK: - UsageTracker
+
+bool Metal::StateTracker::UsageTracker::PrepareForAllocation(u64 last_draw, size_t amt)
+{
+  auto removeme = std::find_if(m_usage.begin(), m_usage.end(),
+                               [last_draw](UsageEntry usage) { return usage.drawno > last_draw; });
+  if (removeme != m_usage.begin())
+    m_usage.erase(m_usage.begin(), removeme);
+
+  bool still_in_use = false;
+  const bool needs_wrap = m_pos + amt > m_size;
+  if (!m_usage.empty())
+  {
+    size_t used = m_usage.front().pos;
+    if (needs_wrap)
+      still_in_use = used >= m_pos || used < amt;
+    else
+      still_in_use = used >= m_pos && used < m_pos + amt;
+  }
+  if (needs_wrap)
+    m_pos = 0;
+
+  return still_in_use || amt > m_size;
+}
+
+size_t Metal::StateTracker::UsageTracker::Allocate(u64 current_draw, size_t amt)
+{
+  if (m_usage.empty() || m_usage.back().drawno != current_draw)
+    m_usage.push_back({current_draw, m_pos});
+  size_t ret = m_pos;
+  m_pos += amt;
+  return ret;
+}
+
+void Metal::StateTracker::UsageTracker::Reset(size_t new_size)
+{
+  m_usage.clear();
+  m_size = new_size;
+  m_pos = 0;
+}
+
+// MARK: - StateTracker
+
+Metal::StateTracker::StateTracker() : m_backref(std::make_shared<Backref>(this))
+{
+  m_flags.should_apply_label = true;
+  m_fence = MRCTransfer([g_device newFence]);
+  for (MRCOwned<MTLRenderPassDescriptor*>& rpdesc : m_render_pass_desc)
+  {
+    rpdesc = MRCTransfer([MTLRenderPassDescriptor new]);
+    [[rpdesc depthAttachment] setStoreAction:MTLStoreActionStore];
+    [[rpdesc stencilAttachment] setStoreAction:MTLStoreActionStore];
+  }
+  m_resolve_pass_desc = MRCTransfer([MTLRenderPassDescriptor new]);
+  auto color0 = [[m_resolve_pass_desc colorAttachments] objectAtIndexedSubscript:0];
+  [color0 setLoadAction:MTLLoadActionLoad];
+  [color0 setStoreAction:MTLStoreActionMultisampleResolve];
+  MTLTextureDescriptor* texdesc =
+      [MTLTextureDescriptor texture2DDescriptorWithPixelFormat:MTLPixelFormatRGBA8Unorm
+                                                         width:1
+                                                        height:1
+                                                     mipmapped:NO];
+  [texdesc setTextureType:MTLTextureType2DArray];
+  [texdesc setUsage:MTLTextureUsageShaderRead];
+  [texdesc setStorageMode:MTLStorageModePrivate];
+  m_dummy_texture = MRCTransfer([g_device newTextureWithDescriptor:texdesc]);
+  [m_dummy_texture setLabel:@"Dummy Texture"];
+  for (size_t i = 0; i < std::size(m_state.samplers); ++i)
+  {
+    SetSamplerForce(i, RenderState::GetLinearSamplerState());
+    SetTexture(i, m_dummy_texture);
+  }
+}
+
+Metal::StateTracker::~StateTracker()
+{
+  FlushEncoders();
+  std::lock_guard<std::mutex> lock(m_backref->mtx);
+  m_backref->state_tracker = nullptr;
+}
+
+// MARK: BufferPair Ops
+
+Metal::StateTracker::Map Metal::StateTracker::AllocateForTextureUpload(size_t amt)
+{
+  amt = (amt + 15) & ~15ull;
+  CPUBuffer& buffer = m_texture_upload_buffer;
+  u64 last_draw = m_last_finished_draw.load(std::memory_order_acquire);
+  bool needs_new = buffer.usage.PrepareForAllocation(last_draw, amt);
+  if (__builtin_expect(needs_new, false))
+  {
+    // Orphan buffer
+    size_t newsize = std::max<size_t>(buffer.usage.Size() * 2, 4096);
+    while (newsize < amt)
+      newsize *= 2;
+    MTLResourceOptions options =
+        MTLResourceStorageModeShared | MTLResourceCPUCacheModeWriteCombined;
+    buffer.mtlbuffer = MRCTransfer([g_device newBufferWithLength:newsize options:options]);
+    [buffer.mtlbuffer setLabel:@"Texture Upload Buffer"];
+    ASSERT_MSG(VIDEO, buffer.mtlbuffer, "Failed to allocate MTLBuffer (out of memory?)");
+    buffer.buffer = [buffer.mtlbuffer contents];
+    buffer.usage.Reset(newsize);
+  }
+
+  size_t pos = buffer.usage.Allocate(m_current_draw, amt);
+
+  Map ret = {buffer.mtlbuffer, pos, reinterpret_cast<char*>(buffer.buffer) + pos};
+  DEBUG_ASSERT(pos <= buffer.usage.Size() &&
+               "Previous code should have guaranteed there was enough space");
+  return ret;
+}
+
+void* Metal::StateTracker::Preallocate(UploadBuffer buffer_idx, size_t amt)
+{
+  BufferPair& buffer = m_upload_buffers[static_cast<int>(buffer_idx)];
+  u64 last_draw = m_last_finished_draw.load(std::memory_order_acquire);
+  size_t base_pos = buffer.usage.Pos();
+  bool needs_new = buffer.usage.PrepareForAllocation(last_draw, amt);
+  bool needs_upload = needs_new || buffer.usage.Pos() == 0;
+  if (!g_features.unified_memory && needs_upload)
+  {
+    if (base_pos != buffer.last_upload)
+    {
+      id<MTLBlitCommandEncoder> encoder = GetUploadEncoder();
+      [encoder copyFromBuffer:buffer.cpubuffer
+                 sourceOffset:buffer.last_upload
+                     toBuffer:buffer.gpubuffer
+            destinationOffset:buffer.last_upload
+                         size:base_pos - buffer.last_upload];
+    }
+    buffer.last_upload = 0;
+  }
+  if (__builtin_expect(needs_new, false))
+  {
+    // Orphan buffer
+    size_t newsize = std::max<size_t>(buffer.usage.Size() * 2, 4096);
+    while (newsize < amt)
+      newsize *= 2;
+    MTLResourceOptions options =
+        MTLResourceStorageModeShared | MTLResourceCPUCacheModeWriteCombined;
+    buffer.cpubuffer = MRCTransfer([g_device newBufferWithLength:newsize options:options]);
+    [buffer.cpubuffer setLabel:GetName(buffer_idx)];
+    ASSERT_MSG(VIDEO, buffer.cpubuffer, "Failed to allocate MTLBuffer (out of memory?)");
+    buffer.buffer = [buffer.cpubuffer contents];
+    buffer.usage.Reset(newsize);
+    if (!g_features.unified_memory)
+    {
+      options = MTLResourceStorageModePrivate | MTLResourceHazardTrackingModeUntracked;
+      buffer.gpubuffer = MRCTransfer([g_device newBufferWithLength:newsize options:options]);
+      [buffer.gpubuffer setLabel:GetName(buffer_idx)];
+      ASSERT_MSG(VIDEO, buffer.gpubuffer, "Failed to allocate MTLBuffer (out of memory?)");
+    }
+  }
+  return reinterpret_cast<char*>(buffer.buffer) + buffer.usage.Pos();
+}
+
+Metal::StateTracker::Map Metal::StateTracker::CommitPreallocation(UploadBuffer buffer_idx,
+                                                                  size_t amt)
+{
+  BufferPair& buffer = m_upload_buffers[static_cast<int>(buffer_idx)];
+  size_t pos = buffer.usage.Allocate(m_current_draw, amt);
+  Map ret = {nil, pos, reinterpret_cast<char*>(buffer.buffer) + pos};
+  ret.gpu_buffer = g_features.unified_memory ? buffer.cpubuffer : buffer.gpubuffer;
+  DEBUG_ASSERT(pos <= buffer.usage.Size() &&
+               "Previous code should have guaranteed there was enough space");
+  return ret;
+}
+
+void Metal::StateTracker::Sync(BufferPair& buffer)
+{
+  if (g_features.unified_memory || buffer.usage.Pos() == buffer.last_upload)
+    return;
+
+  id<MTLBlitCommandEncoder> encoder = GetUploadEncoder();
+  [encoder copyFromBuffer:buffer.cpubuffer
+             sourceOffset:buffer.last_upload
+                 toBuffer:buffer.gpubuffer
+        destinationOffset:buffer.last_upload
+                     size:buffer.usage.Pos() - buffer.last_upload];
+  buffer.last_upload = buffer.usage.Pos();
+}
+
+// MARK: Render Pass / Encoder Management
+
+id<MTLBlitCommandEncoder> Metal::StateTracker::GetUploadEncoder()
+{
+  if (!m_upload_cmdbuf)
+  {
+    @autoreleasepool
+    {
+      m_upload_cmdbuf = MRCRetain([g_queue commandBuffer]);
+      [m_upload_cmdbuf setLabel:@"Vertex Upload"];
+      m_upload_encoder = MRCRetain([m_upload_cmdbuf blitCommandEncoder]);
+      [m_upload_encoder setLabel:@"Vertex Upload"];
+    }
+  }
+  return m_upload_encoder;
+}
+
+id<MTLBlitCommandEncoder> Metal::StateTracker::GetTextureUploadEncoder()
+{
+  if (!m_texture_upload_cmdbuf)
+  {
+    @autoreleasepool
+    {
+      m_texture_upload_cmdbuf = MRCRetain([g_queue commandBuffer]);
+      [m_texture_upload_cmdbuf setLabel:@"Texture Upload"];
+      m_texture_upload_encoder = MRCRetain([m_texture_upload_cmdbuf blitCommandEncoder]);
+      [m_texture_upload_encoder setLabel:@"Texture Upload"];
+    }
+  }
+  return m_texture_upload_encoder;
+}
+
+id<MTLCommandBuffer> Metal::StateTracker::GetRenderCmdBuf()
+{
+  if (!m_current_render_cmdbuf)
+  {
+    @autoreleasepool
+    {
+      m_current_render_cmdbuf = MRCRetain([g_queue commandBuffer]);
+      [m_current_render_cmdbuf setLabel:@"Draw"];
+    }
+  }
+  return m_current_render_cmdbuf;
+}
+
+void Metal::StateTracker::SetCurrentFramebuffer(Framebuffer* framebuffer)
+{
+  if (framebuffer == m_current_framebuffer)
+    return;
+  EndRenderPass();
+  m_current_framebuffer = framebuffer;
+}
+
+MTLRenderPassDescriptor* Metal::StateTracker::GetRenderPassDescriptor(Framebuffer* framebuffer,
+                                                                      MTLLoadAction load_action)
+{
+  const AbstractTextureFormat depth_fmt = framebuffer->GetDepthFormat();
+  MTLRenderPassDescriptor* desc;
+  if (depth_fmt == AbstractTextureFormat::Undefined)
+    desc = m_render_pass_desc[0];
+  else if (!Util::HasStencil(depth_fmt))
+    desc = m_render_pass_desc[1];
+  else
+    desc = m_render_pass_desc[2];
+  desc.colorAttachments[0].texture = framebuffer->GetColor();
+  desc.colorAttachments[0].loadAction = load_action;
+  if (depth_fmt != AbstractTextureFormat::Undefined)
+  {
+    desc.depthAttachment.texture = framebuffer->GetDepth();
+    desc.depthAttachment.loadAction = load_action;
+    if (Util::HasStencil(depth_fmt))
+    {
+      desc.stencilAttachment.texture = framebuffer->GetDepth();
+      desc.stencilAttachment.loadAction = load_action;
+    }
+  }
+  return desc;
+}
+
+void Metal::StateTracker::BeginClearRenderPass(MTLClearColor color, float depth)
+{
+  Framebuffer* framebuffer = m_current_framebuffer;
+  MTLRenderPassDescriptor* desc = GetRenderPassDescriptor(framebuffer, MTLLoadActionClear);
+  desc.colorAttachments[0].clearColor = color;
+  if (framebuffer->GetDepthFormat() != AbstractTextureFormat::Undefined)
+  {
+    desc.depthAttachment.clearDepth = depth;
+    if (Util::HasStencil(framebuffer->GetDepthFormat()))
+      desc.stencilAttachment.clearStencil = 0;
+  }
+  BeginRenderPass(desc);
+}
+
+void Metal::StateTracker::BeginRenderPass(MTLLoadAction load_action)
+{
+  if (m_current_render_encoder)
+    return;
+  BeginRenderPass(GetRenderPassDescriptor(m_current_framebuffer, load_action));
+}
+
+void Metal::StateTracker::BeginRenderPass(MTLRenderPassDescriptor* descriptor)
+{
+  EndRenderPass();
+  m_current_render_encoder =
+      MRCRetain([GetRenderCmdBuf() renderCommandEncoderWithDescriptor:descriptor]);
+  if (!g_features.unified_memory)
+    [m_current_render_encoder waitForFence:m_fence beforeStages:MTLRenderStageVertex];
+  AbstractTexture* attachment = m_current_framebuffer->GetColorAttachment();
+  if (!attachment)
+    attachment = m_current_framebuffer->GetDepthAttachment();
+  static_assert(std::is_trivially_copyable<decltype(m_current)>::value,
+                "Make sure we can memset this");
+  memset(&m_current, 0, sizeof(m_current));
+  m_current.width = attachment->GetWidth();
+  m_current.height = attachment->GetHeight();
+  m_current.scissor_rect = MathUtil::Rectangle<int>(0, 0, m_current.width, m_current.height);
+  m_current.viewport = {
+      0.f, 0.f, static_cast<float>(m_current.width), static_cast<float>(m_current.height),
+      0.f, 1.f};
+  m_current.depth_stencil = DepthStencilSelector(false, CompareMode::Always);
+  m_current.depth_clip_mode = MTLDepthClipModeClip;
+  m_current.cull_mode = MTLCullModeNone;
+  m_flags.NewEncoder();
+  m_dirty_samplers = 0xff;
+  m_dirty_textures = 0xff;
+  CheckScissor();
+  CheckViewport();
+  ASSERT_MSG(VIDEO, m_current_render_encoder, "Failed to create render encoder!");
+}
+
+void Metal::StateTracker::BeginComputePass()
+{
+  EndRenderPass();
+  m_current_compute_encoder = MRCRetain([GetRenderCmdBuf() computeCommandEncoder]);
+  [m_current_compute_encoder setLabel:@"Compute"];
+  if (!g_features.unified_memory)
+    [m_current_compute_encoder waitForFence:m_fence];
+  m_flags.NewEncoder();
+  m_dirty_samplers = 0xff;
+  m_dirty_textures = 0xff;
+}
+
+void Metal::StateTracker::EndRenderPass()
+{
+  if (m_current_render_encoder)
+  {
+    if (m_flags.bbox_fence && m_state.bbox_download_fence)
+      [m_current_render_encoder updateFence:m_state.bbox_download_fence
+                                afterStages:MTLRenderStageFragment];
+    [m_current_render_encoder endEncoding];
+    m_current_render_encoder = nullptr;
+  }
+  if (m_current_compute_encoder)
+  {
+    [m_current_compute_encoder endEncoding];
+    m_current_compute_encoder = nullptr;
+  }
+}
+
+void Metal::StateTracker::FlushEncoders()
+{
+  if (!m_current_render_cmdbuf)
+    return;
+  EndRenderPass();
+  for (int i = 0; i <= static_cast<int>(UploadBuffer::Last); ++i)
+    Sync(m_upload_buffers[i]);
+  if (g_features.unified_memory)
+  {
+    ASSERT(!m_upload_cmdbuf && "Should never be used!");
+  }
+  else if (m_upload_cmdbuf)
+  {
+    [m_upload_encoder updateFence:m_fence];
+    [m_upload_encoder endEncoding];
+    [m_upload_cmdbuf commit];
+    m_upload_encoder = nullptr;
+    m_upload_cmdbuf = nullptr;
+  }
+  if (m_texture_upload_cmdbuf)
+  {
+    [m_texture_upload_encoder endEncoding];
+    [m_texture_upload_cmdbuf commit];
+    m_texture_upload_encoder = nullptr;
+    m_texture_upload_cmdbuf = nullptr;
+  }
+  [m_current_render_cmdbuf
+    addCompletedHandler:[backref = m_backref, draw = m_current_draw](id<MTLCommandBuffer> buf) {
+      std::lock_guard<std::mutex> guard(backref->mtx);
+      if (StateTracker* tracker = backref->state_tracker)
+      {
+        // We can do the update non-atomically because we only ever update under the lock
+        u64 newval = std::max(draw, tracker->m_last_finished_draw.load(std::memory_order_relaxed));
+        tracker->m_last_finished_draw.store(newval, std::memory_order_release);
+      }
+    }];
+  [m_current_render_cmdbuf commit];
+  m_last_render_cmdbuf = std::move(m_current_render_cmdbuf);
+  m_current_render_cmdbuf = nullptr;
+  m_current_draw++;
+}
+
+void Metal::StateTracker::WaitForFlushedEncoders()
+{
+  [m_last_render_cmdbuf waitUntilCompleted];
+}
+
+void Metal::StateTracker::ReloadSamplers()
+{
+  for (size_t i = 0; i < std::size(m_state.samplers); ++i)
+    m_state.samplers[i] = g_object_cache->GetSampler(m_state.sampler_states[i]);
+}
+
+// MARK: State Setters
+
+void Metal::StateTracker::SetPipeline(const Pipeline* pipe)
+{
+  if (pipe != m_state.render_pipeline)
+  {
+    m_state.render_pipeline = pipe;
+    m_flags.has_pipeline = false;
+  }
+}
+
+void Metal::StateTracker::SetPipeline(const ComputePipeline* pipe)
+{
+  if (pipe != m_state.compute_pipeline)
+  {
+    m_state.compute_pipeline = pipe;
+    m_flags.has_pipeline = false;
+  }
+}
+
+void Metal::StateTracker::SetScissor(const MathUtil::Rectangle<int>& rect)
+{
+  m_state.scissor_rect = rect;
+  CheckScissor();
+}
+
+void Metal::StateTracker::CheckScissor()
+{
+  auto clipped = m_state.scissor_rect;
+  clipped.ClampUL(0, 0, m_current.width, m_current.height);
+  m_flags.has_scissor = clipped == m_current.scissor_rect;
+}
+
+void Metal::StateTracker::SetViewport(float x, float y, float width, float height, float near_depth,
+                                      float far_depth)
+{
+  m_state.viewport = {x, y, width, height, near_depth, far_depth};
+  CheckViewport();
+}
+
+void Metal::StateTracker::CheckViewport()
+{
+  m_flags.has_viewport =
+      0 == memcmp(&m_state.viewport, &m_current.viewport, sizeof(m_current.viewport));
+}
+
+void Metal::StateTracker::SetTexture(u32 idx, id<MTLTexture> texture)
+{
+  ASSERT(idx < std::size(m_state.textures));
+  if (!texture)
+    texture = m_dummy_texture;
+  if (m_state.textures[idx] != texture)
+  {
+    m_state.textures[idx] = texture;
+    m_dirty_textures |= 1 << idx;
+  }
+}
+
+void Metal::StateTracker::SetSamplerForce(u32 idx, const SamplerState& sampler)
+{
+  m_state.samplers[idx] = g_object_cache->GetSampler(sampler);
+  m_state.sampler_min_lod[idx] = sampler.tm1.min_lod;
+  m_state.sampler_max_lod[idx] = sampler.tm1.max_lod;
+  m_state.sampler_states[idx] = sampler;
+  m_dirty_samplers |= 1 << idx;
+}
+
+void Metal::StateTracker::SetSampler(u32 idx, const SamplerState& sampler)
+{
+  ASSERT(idx < std::size(m_state.samplers));
+  if (m_state.sampler_states[idx] != sampler)
+    SetSamplerForce(idx, sampler);
+}
+
+void Metal::StateTracker::SetComputeTexture(const Texture* texture)
+{
+  if (m_state.compute_texture != texture)
+  {
+    m_state.compute_texture = texture;
+    m_flags.has_compute_texture = false;
+  }
+}
+
+void Metal::StateTracker::UnbindTexture(id<MTLTexture> texture)
+{
+  for (size_t i = 0; i < std::size(m_state.textures); ++i)
+  {
+    if (m_state.textures[i] == texture)
+    {
+      m_state.textures[i] = m_dummy_texture;
+      m_dirty_textures |= 1 << i;
+    }
+  }
+}
+
+void Metal::StateTracker::InvalidateUniforms(bool vertex, bool fragment)
+{
+  m_flags.has_gx_vs_uniform &= !vertex;
+  m_flags.has_gx_ps_uniform &= !fragment;
+}
+
+void Metal::StateTracker::SetUtilityUniform(const void* buffer, size_t size)
+{
+  if (m_state.utility_uniform_capacity < size)
+  {
+    m_state.utility_uniform = std::unique_ptr<u8[]>(new u8[size]);
+    m_state.utility_uniform_capacity = size;
+  }
+  m_state.utility_uniform_size = size;
+  memcpy(m_state.utility_uniform.get(), buffer, size);
+  m_flags.has_utility_vs_uniform = false;
+  m_flags.has_utility_ps_uniform = false;
+}
+
+void Metal::StateTracker::SetTexelBuffer(id<MTLBuffer> buffer, u32 offset0, u32 offset1)
+{
+  m_state.texels = buffer;
+  m_state.texel_buffer_offset0 = offset0;
+  m_state.texel_buffer_offset1 = offset1;
+  m_flags.has_texel_buffer = false;
+}
+
+void Metal::StateTracker::SetVerticesAndIndices(Map vertices, Map indices)
+{
+  m_state.vertices = vertices.gpu_buffer;
+  m_state.indices = indices.gpu_buffer;
+  m_state.vertices_offset = vertices.gpu_offset;
+  m_state.indices_offset = indices.gpu_offset;
+  m_flags.has_vertices = false;
+}
+
+void Metal::StateTracker::SetBBoxBuffer(id<MTLBuffer> bbox, id<MTLFence> upload,
+                                        id<MTLFence> download)
+{
+  m_state.bbox = bbox;
+  m_state.bbox_upload_fence = upload;
+  m_state.bbox_download_fence = download;
+}
+
+void Metal::StateTracker::SetVertexBufferNow(u32 idx, id<MTLBuffer> buffer, u32 offset)
+{
+  if (idx < std::size(m_current.vertex_buffers) && m_current.vertex_buffers[idx] == buffer)
+  {
+    [m_current_render_encoder setVertexBufferOffset:offset atIndex:idx];
+  }
+  else
+  {
+    [m_current_render_encoder setVertexBuffer:buffer offset:offset atIndex:idx];
+    m_current.vertex_buffers[idx] = buffer;
+  }
+}
+
+void Metal::StateTracker::SetFragmentBufferNow(u32 idx, id<MTLBuffer> buffer, u32 offset)
+{
+  if (idx < std::size(m_current.fragment_buffers) && m_current.fragment_buffers[idx] == buffer)
+  {
+    [m_current_render_encoder setFragmentBufferOffset:offset atIndex:idx];
+  }
+  else
+  {
+    [m_current_render_encoder setFragmentBuffer:buffer offset:offset atIndex:idx];
+    m_current.fragment_buffers[idx] = buffer;
+  }
+}
+
+// MARK: Render
+
+// clang-format off
+static constexpr NSString* LABEL_GX   = @"GX Draw";
+static constexpr NSString* LABEL_UTIL = @"Utility Draw";
+// clang-format on
+
+static NSRange RangeOfBits(u32 value)
+{
+  ASSERT(value && "Value must be nonzero");
+  u32 low = Common::CountTrailingZeros(value);
+  u32 high = 31 - Common::CountLeadingZeros(value);
+  return NSMakeRange(low, high + 1 - low);
+}
+
+void Metal::StateTracker::PrepareRender()
+{
+  if (!m_current_render_encoder)
+    BeginRenderPass(MTLLoadActionLoad);
+  id<MTLRenderCommandEncoder> enc = m_current_render_encoder;
+  const Pipeline* pipe = m_state.render_pipeline;
+  bool is_gx = pipe->Usage() == AbstractPipelineUsage::GX;
+  NSString* label = is_gx ? LABEL_GX : LABEL_UTIL;
+  if (m_flags.should_apply_label && m_current.label != label)
+  {
+    m_current.label = label;
+    [m_current_render_encoder setLabel:label];
+  }
+  if (!m_flags.has_pipeline)
+  {
+    m_flags.has_pipeline = true;
+    if (pipe->Get() != m_current.pipeline)
+    {
+      m_current.pipeline = pipe->Get();
+      [enc setRenderPipelineState:pipe->Get()];
+    }
+    if (pipe->Cull() != m_current.cull_mode)
+    {
+      m_current.cull_mode = pipe->Cull();
+      [enc setCullMode:pipe->Cull()];
+    }
+    if (pipe->DepthStencil() != m_current.depth_stencil)
+    {
+      m_current.depth_stencil = pipe->DepthStencil();
+      [enc setDepthStencilState:g_object_cache->GetDepthStencil(m_current.depth_stencil)];
+    }
+    MTLDepthClipMode clip = is_gx && g_ActiveConfig.backend_info.bSupportsDepthClamp ?
+                                MTLDepthClipModeClamp :
+                                MTLDepthClipModeClip;
+    if (clip != m_current.depth_clip_mode)
+    {
+      m_current.depth_clip_mode = clip;
+      [enc setDepthClipMode:clip];
+    }
+    if (is_gx && m_state.bbox_upload_fence && !m_flags.bbox_fence && pipe->UsesFragmentBuffer(2))
+    {
+      m_flags.bbox_fence = true;
+      [enc waitForFence:m_state.bbox_upload_fence beforeStages:MTLRenderStageFragment];
+      [enc setFragmentBuffer:m_state.bbox offset:0 atIndex:2];
+    }
+  }
+  if (!m_flags.has_viewport)
+  {
+    m_flags.has_viewport = true;
+    m_current.viewport = m_state.viewport;
+    MTLViewport metal;
+    metal.originX = m_state.viewport.x;
+    metal.originY = m_state.viewport.y;
+    metal.width = m_state.viewport.width;
+    metal.height = m_state.viewport.height;
+    metal.znear = m_state.viewport.near_depth;
+    metal.zfar = m_state.viewport.far_depth;
+    [enc setViewport:metal];
+  }
+  if (!m_flags.has_scissor)
+  {
+    m_flags.has_scissor = true;
+    m_current.scissor_rect = m_state.scissor_rect;
+    m_current.scissor_rect.ClampUL(0, 0, m_current.width, m_current.height);
+    MTLScissorRect metal;
+    metal.x = m_current.scissor_rect.left;
+    metal.y = m_current.scissor_rect.top;
+    metal.width = m_current.scissor_rect.right - m_current.scissor_rect.left;
+    metal.height = m_current.scissor_rect.bottom - m_current.scissor_rect.top;
+    [enc setScissorRect:metal];
+  }
+  if (!m_flags.has_vertices && pipe->UsesVertexBuffer(0))
+  {
+    m_flags.has_vertices = true;
+    if (m_state.vertices)
+      SetVertexBufferNow(0, m_state.vertices, m_state.vertices_offset);
+  }
+  if (u8 dirty = m_dirty_textures & pipe->GetTextures())
+  {
+    m_dirty_textures &= ~pipe->GetTextures();
+    NSRange range = RangeOfBits(dirty);
+    [enc setFragmentTextures:&m_state.textures[range.location] withRange:range];
+  }
+  if (u8 dirty = m_dirty_samplers & pipe->GetSamplers())
+  {
+    m_dirty_samplers &= ~pipe->GetSamplers();
+    NSRange range = RangeOfBits(dirty);
+    [enc setFragmentSamplerStates:&m_state.samplers[range.location]
+                     lodMinClamps:m_state.sampler_min_lod.data()
+                     lodMaxClamps:m_state.sampler_max_lod.data()
+                        withRange:range];
+  }
+  if (is_gx)
+  {
+    // GX draw
+    if (!m_flags.has_gx_vs_uniform)
+    {
+      m_flags.has_gx_vs_uniform = true;
+      Map map = Allocate(UploadBuffer::Uniform, sizeof(VertexShaderConstants), AlignMask::Uniform);
+      memcpy(map.cpu_buffer, &VertexShaderManager::constants, sizeof(VertexShaderConstants));
+      SetVertexBufferNow(1, map.gpu_buffer, map.gpu_offset);
+      if (pipe->UsesFragmentBuffer(1))
+        SetFragmentBufferNow(1, map.gpu_buffer, map.gpu_offset);
+      ADDSTAT(g_stats.this_frame.bytes_uniform_streamed,
+              Align(sizeof(VertexShaderConstants), AlignMask::Uniform));
+    }
+    if (!m_flags.has_gx_ps_uniform)
+    {
+      m_flags.has_gx_ps_uniform = true;
+      Map map = Allocate(UploadBuffer::Uniform, sizeof(PixelShaderConstants), AlignMask::Uniform);
+      memcpy(map.cpu_buffer, &PixelShaderManager::constants, sizeof(PixelShaderConstants));
+      SetFragmentBufferNow(0, map.gpu_buffer, map.gpu_offset);
+      ADDSTAT(g_stats.this_frame.bytes_uniform_streamed,
+              Align(sizeof(PixelShaderConstants), AlignMask::Uniform));
+    }
+  }
+  else
+  {
+    // Utility draw
+    if (!m_flags.has_utility_vs_uniform && pipe->UsesVertexBuffer(1))
+    {
+      m_flags.has_utility_vs_uniform = true;
+      m_flags.has_gx_vs_uniform = false;
+      [enc setVertexBytes:m_state.utility_uniform.get()
+                   length:m_state.utility_uniform_size
+                  atIndex:1];
+    }
+    if (!m_flags.has_utility_ps_uniform && pipe->UsesFragmentBuffer(0))
+    {
+      m_flags.has_utility_ps_uniform = true;
+      m_flags.has_gx_ps_uniform = false;
+      [enc setFragmentBytes:m_state.utility_uniform.get()
+                     length:m_state.utility_uniform_size
+                    atIndex:0];
+    }
+    if (!m_flags.has_texel_buffer && pipe->UsesFragmentBuffer(2))
+    {
+      m_flags.has_texel_buffer = true;
+      SetFragmentBufferNow(2, m_state.texels, m_state.texel_buffer_offset0);
+    }
+  }
+}
+
+void Metal::StateTracker::PrepareCompute()
+{
+  if (!m_current_compute_encoder)
+    BeginComputePass();
+  id<MTLComputeCommandEncoder> enc = m_current_compute_encoder;
+  const ComputePipeline* pipe = m_state.compute_pipeline;
+  if (!m_flags.has_pipeline)
+  {
+    m_flags.has_pipeline = true;
+    [enc setComputePipelineState:pipe->GetComputePipeline()];
+  }
+  if (!m_flags.has_compute_texture && pipe->UsesTexture(0))
+  {
+    m_flags.has_compute_texture = true;
+    [enc setTexture:m_state.compute_texture->GetMTLTexture() atIndex:0];
+  }
+  // Compute and render can't happen at the same time, so just reuse one of the flags
+  if (!m_flags.has_utility_vs_uniform && pipe->UsesBuffer(0))
+  {
+    m_flags.has_utility_vs_uniform = true;
+    [enc setBytes:m_state.utility_uniform.get() length:m_state.utility_uniform_size atIndex:0];
+  }
+  if (!m_flags.has_texel_buffer && pipe->UsesBuffer(2))
+  {
+    m_flags.has_texel_buffer = true;
+    [enc setBuffer:m_state.texels offset:m_state.texel_buffer_offset0 atIndex:2];
+    if (pipe->UsesBuffer(3))
+      [enc setBuffer:m_state.texels offset:m_state.texel_buffer_offset1 atIndex:3];
+  }
+}
+
+void Metal::StateTracker::Draw(u32 base_vertex, u32 num_vertices)
+{
+  PrepareRender();
+  [m_current_render_encoder drawPrimitives:m_state.render_pipeline->Prim()
+                               vertexStart:base_vertex
+                               vertexCount:num_vertices];
+}
+
+void Metal::StateTracker::DrawIndexed(u32 base_index, u32 num_indices, u32 base_vertex)
+{
+  PrepareRender();
+  if (!base_vertex)
+  {
+    [m_current_render_encoder
+        drawIndexedPrimitives:m_state.render_pipeline->Prim()
+                   indexCount:num_indices
+                    indexType:MTLIndexTypeUInt16
+                  indexBuffer:m_state.indices
+            indexBufferOffset:m_state.indices_offset + base_index * sizeof(u16)];
+  }
+  else
+  {
+    [m_current_render_encoder
+        drawIndexedPrimitives:m_state.render_pipeline->Prim()
+                   indexCount:num_indices
+                    indexType:MTLIndexTypeUInt16
+                  indexBuffer:m_state.indices
+            indexBufferOffset:m_state.indices_offset + base_index * sizeof(u16)
+                instanceCount:1
+                   baseVertex:base_vertex
+                 baseInstance:0];
+  }
+}
+
+void Metal::StateTracker::DispatchComputeShader(u32 groupsize_x, u32 groupsize_y, u32 groupsize_z,
+                                                u32 groups_x, u32 groups_y, u32 groups_z)
+{
+  PrepareCompute();
+  [m_current_compute_encoder
+       dispatchThreadgroups:MTLSizeMake(groups_x, groups_y, groups_z)
+      threadsPerThreadgroup:MTLSizeMake(groupsize_x, groupsize_y, groupsize_z)];
+}
+
+void Metal::StateTracker::ResolveTexture(id<MTLTexture> src, id<MTLTexture> dst, u32 layer,
+                                         u32 level)
+{
+  EndRenderPass();
+  auto color0 = [[m_resolve_pass_desc colorAttachments] objectAtIndexedSubscript:0];
+  [color0 setTexture:src];
+  [color0 setResolveTexture:dst];
+  [color0 setResolveSlice:layer];
+  [color0 setResolveLevel:level];
+  id<MTLRenderCommandEncoder> enc =
+      [GetRenderCmdBuf() renderCommandEncoderWithDescriptor:m_resolve_pass_desc];
+  [enc setLabel:@"Multisample Resolve"];
+  [enc endEncoding];
+}

Source/Core/VideoBackends/Metal/MTLTexture.h

@@ -0,0 +1,77 @@
+// Copyright 2022 Dolphin Emulator Project
+// SPDX-License-Identifier: GPL-2.0-or-later
+
+#pragma once
+
+#include <Metal/Metal.h>
+
+#include "VideoCommon/AbstractFramebuffer.h"
+#include "VideoCommon/AbstractStagingTexture.h"
+#include "VideoCommon/AbstractTexture.h"
+
+#include "VideoBackends/Metal/MRCHelpers.h"
+
+namespace Metal
+{
+class Texture final : public AbstractTexture
+{
+public:
+  explicit Texture(MRCOwned<id<MTLTexture>> tex, const TextureConfig& config);
+  ~Texture();
+
+  void CopyRectangleFromTexture(const AbstractTexture* src,
+                                const MathUtil::Rectangle<int>& src_rect, u32 src_layer,
+                                u32 src_level, const MathUtil::Rectangle<int>& dst_rect,
+                                u32 dst_layer, u32 dst_level) override;
+  void ResolveFromTexture(const AbstractTexture* src, const MathUtil::Rectangle<int>& rect,
+                          u32 layer, u32 level) override;
+  void Load(u32 level, u32 width, u32 height, u32 row_length, const u8* buffer,
+            size_t buffer_size) override;
+
+  id<MTLTexture> GetMTLTexture() const { return m_tex; }
+  void SetMTLTexture(MRCOwned<id<MTLTexture>> tex) { m_tex = std::move(tex); }
+
+private:
+  MRCOwned<id<MTLTexture>> m_tex;
+};
+
+class StagingTexture final : public AbstractStagingTexture
+{
+public:
+  StagingTexture(MRCOwned<id<MTLBuffer>> buffer, StagingTextureType type,
+                 const TextureConfig& config);
+  ~StagingTexture();
+
+  void CopyFromTexture(const AbstractTexture* src, const MathUtil::Rectangle<int>& src_rect,
+                       u32 src_layer, u32 src_level,
+                       const MathUtil::Rectangle<int>& dst_rect) override;
+  void CopyToTexture(const MathUtil::Rectangle<int>& src_rect, AbstractTexture* dst,
+                     const MathUtil::Rectangle<int>& dst_rect, u32 dst_layer,
+                     u32 dst_level) override;
+
+  bool Map() override;
+  void Unmap() override;
+  void Flush() override;
+
+private:
+  MRCOwned<id<MTLBuffer>> m_buffer;
+  MRCOwned<id<MTLCommandBuffer>> m_wait_buffer;
+};
+
+class Framebuffer final : public AbstractFramebuffer
+{
+public:
+  Framebuffer(AbstractTexture* color, AbstractTexture* depth, u32 width, u32 height, u32 layers,
+              u32 samples);
+  ~Framebuffer();
+
+  id<MTLTexture> GetColor() const
+  {
+    return static_cast<Texture*>(GetColorAttachment())->GetMTLTexture();
+  }
+  id<MTLTexture> GetDepth() const
+  {
+    return static_cast<Texture*>(GetDepthAttachment())->GetMTLTexture();
+  }
+};
+}  // namespace Metal

Source/Core/VideoBackends/Metal/MTLTexture.mm

@@ -0,0 +1,179 @@
+// Copyright 2022 Dolphin Emulator Project
+// SPDX-License-Identifier: GPL-2.0-or-later
+
+#include "VideoBackends/Metal/MTLTexture.h"
+
+#include "Common/Align.h"
+#include "Common/Assert.h"
+
+#include "VideoBackends/Metal/MTLStateTracker.h"
+
+Metal::Texture::Texture(MRCOwned<id<MTLTexture>> tex, const TextureConfig& config)
+    : AbstractTexture(config), m_tex(std::move(tex))
+{
+}
+
+Metal::Texture::~Texture()
+{
+  if (g_state_tracker)
+    g_state_tracker->UnbindTexture(m_tex);
+}
+
+void Metal::Texture::CopyRectangleFromTexture(const AbstractTexture* src,
+                                              const MathUtil::Rectangle<int>& src_rect,
+                                              u32 src_layer, u32 src_level,
+                                              const MathUtil::Rectangle<int>& dst_rect,
+                                              u32 dst_layer, u32 dst_level)
+{
+  g_state_tracker->EndRenderPass();
+  id<MTLTexture> msrc = static_cast<const Texture*>(src)->GetMTLTexture();
+  id<MTLBlitCommandEncoder> blit = [g_state_tracker->GetRenderCmdBuf() blitCommandEncoder];
+  MTLSize size = MTLSizeMake(src_rect.right - src_rect.left, src_rect.bottom - src_rect.top, 1);
+  [blit setLabel:@"Texture Copy"];
+  [blit copyFromTexture:msrc
+            sourceSlice:src_layer
+            sourceLevel:src_level
+           sourceOrigin:MTLOriginMake(src_rect.left, src_rect.top, 0)
+             sourceSize:size
+              toTexture:m_tex
+       destinationSlice:dst_layer
+       destinationLevel:dst_level
+      destinationOrigin:MTLOriginMake(dst_rect.left, dst_rect.top, 0)];
+  [blit endEncoding];
+}
+
+void Metal::Texture::ResolveFromTexture(const AbstractTexture* src,
+                                        const MathUtil::Rectangle<int>& rect, u32 layer, u32 level)
+{
+  ASSERT(rect == MathUtil::Rectangle<int>(0, 0, src->GetWidth(), src->GetHeight()));
+  id<MTLTexture> src_tex = static_cast<const Texture*>(src)->GetMTLTexture();
+  g_state_tracker->ResolveTexture(src_tex, m_tex, layer, level);
+}
+
+void Metal::Texture::Load(u32 level, u32 width, u32 height, u32 row_length,  //
+                          const u8* buffer, size_t buffer_size)
+{
+  @autoreleasepool
+  {
+    const u32 block_size = GetBlockSizeForFormat(GetFormat());
+    const u32 num_rows = Common::AlignUp(height, block_size) / block_size;
+    const u32 source_pitch = CalculateStrideForFormat(m_config.format, row_length);
+    const u32 upload_size = source_pitch * num_rows;
+    StateTracker::Map map = g_state_tracker->AllocateForTextureUpload(upload_size);
+    memcpy(map.cpu_buffer, buffer, upload_size);
+    id<MTLBlitCommandEncoder> encoder = g_state_tracker->GetTextureUploadEncoder();
+    [encoder copyFromBuffer:map.gpu_buffer
+               sourceOffset:map.gpu_offset
+          sourceBytesPerRow:source_pitch
+        sourceBytesPerImage:upload_size
+                 sourceSize:MTLSizeMake(width, height, 1)
+                  toTexture:m_tex
+           destinationSlice:0
+           destinationLevel:level
+          destinationOrigin:MTLOriginMake(0, 0, 0)];
+  }
+}
+
+Metal::StagingTexture::StagingTexture(MRCOwned<id<MTLBuffer>> buffer, StagingTextureType type,
+                                      const TextureConfig& config)
+    : AbstractStagingTexture(type, config), m_buffer(std::move(buffer))
+{
+  m_map_pointer = static_cast<char*>([m_buffer contents]);
+  m_map_stride = config.GetStride();
+}
+
+Metal::StagingTexture::~StagingTexture() = default;
+
+void Metal::StagingTexture::CopyFromTexture(const AbstractTexture* src,
+                                            const MathUtil::Rectangle<int>& src_rect,  //
+                                            u32 src_layer, u32 src_level,
+                                            const MathUtil::Rectangle<int>& dst_rect)
+{
+  @autoreleasepool
+  {
+    const size_t stride = m_config.GetStride();
+    const u32 offset = dst_rect.top * stride + dst_rect.left * m_texel_size;
+    const MTLSize size =
+        MTLSizeMake(src_rect.right - src_rect.left, src_rect.bottom - src_rect.top, 1);
+    g_state_tracker->EndRenderPass();
+    m_wait_buffer = MRCRetain(g_state_tracker->GetRenderCmdBuf());
+    id<MTLBlitCommandEncoder> download_encoder = [m_wait_buffer blitCommandEncoder];
+    [download_encoder setLabel:@"Texture Download"];
+    [download_encoder copyFromTexture:static_cast<const Texture*>(src)->GetMTLTexture()
+                          sourceSlice:src_layer
+                          sourceLevel:src_level
+                         sourceOrigin:MTLOriginMake(src_rect.left, src_rect.top, 0)
+                           sourceSize:size
+                             toBuffer:m_buffer
+                    destinationOffset:offset
+               destinationBytesPerRow:stride
+             destinationBytesPerImage:stride * size.height];
+    [download_encoder endEncoding];
+    m_needs_flush = true;
+  }
+}
+
+void Metal::StagingTexture::CopyToTexture(const MathUtil::Rectangle<int>& src_rect,  //
+                                          AbstractTexture* dst,
+                                          const MathUtil::Rectangle<int>& dst_rect,  //
+                                          u32 dst_layer, u32 dst_level)
+{
+  @autoreleasepool
+  {
+    const size_t stride = m_config.GetStride();
+    const u32 offset = dst_rect.top * stride + dst_rect.left * m_texel_size;
+    const MTLSize size =
+        MTLSizeMake(src_rect.right - src_rect.left, src_rect.bottom - src_rect.top, 1);
+    g_state_tracker->EndRenderPass();
+    m_wait_buffer = MRCRetain(g_state_tracker->GetRenderCmdBuf());
+    id<MTLBlitCommandEncoder> upload_encoder = [m_wait_buffer blitCommandEncoder];
+    [upload_encoder setLabel:@"Texture Upload"];
+    [upload_encoder copyFromBuffer:m_buffer
+                      sourceOffset:offset
+                 sourceBytesPerRow:stride
+               sourceBytesPerImage:stride * size.height
+                        sourceSize:size
+                         toTexture:static_cast<Texture*>(dst)->GetMTLTexture()
+                  destinationSlice:dst_layer
+                  destinationLevel:dst_level
+                 destinationOrigin:MTLOriginMake(dst_rect.left, dst_rect.top, 0)];
+    [upload_encoder endEncoding];
+    m_needs_flush = true;
+  }
+}
+
+bool Metal::StagingTexture::Map()
+{
+  // Always mapped
+  return true;
+}
+
+void Metal::StagingTexture::Unmap()
+{
+  // Always mapped
+}
+
+void Metal::StagingTexture::Flush()
+{
+  m_needs_flush = false;
+  if (!m_wait_buffer)
+    return;
+  if ([m_wait_buffer status] != MTLCommandBufferStatusCompleted)
+  {
+    // Flush while we wait, since who knows how long we'll be sitting here
+    g_state_tracker->FlushEncoders();
+    [m_wait_buffer waitUntilCompleted];
+  }
+  m_wait_buffer = nullptr;
+}
+
+Metal::Framebuffer::Framebuffer(AbstractTexture* color, AbstractTexture* depth,  //
+                                u32 width, u32 height, u32 layers, u32 samples)
+    : AbstractFramebuffer(color, depth,
+                          color ? color->GetFormat() : AbstractTextureFormat::Undefined,  //
+                          depth ? depth->GetFormat() : AbstractTextureFormat::Undefined,  //
+                          width, height, layers, samples)
+{
+}
+
+Metal::Framebuffer::~Framebuffer() = default;

Source/Core/VideoBackends/Metal/MTLUtil.h

@@ -0,0 +1,54 @@
+// Copyright 2022 Dolphin Emulator Project
+// SPDX-License-Identifier: GPL-2.0-or-later
+
+#pragma once
+
+#include <Metal/Metal.h>
+#include <vector>
+
+#include "VideoCommon/AbstractShader.h"
+#include "VideoCommon/TextureConfig.h"
+#include "VideoCommon/VideoConfig.h"
+
+#include "VideoBackends/Metal/MRCHelpers.h"
+
+namespace Metal
+{
+struct DeviceFeatures
+{
+  bool unified_memory;
+  bool subgroup_ops;
+};
+
+extern DeviceFeatures g_features;
+
+namespace Util
+{
+struct Viewport
+{
+  float x;
+  float y;
+  float width;
+  float height;
+  float near_depth;
+  float far_depth;
+};
+
+/// Gets the list of Metal devices, ordered so the system default device is first
+std::vector<MRCOwned<id<MTLDevice>>> GetAdapterList();
+void PopulateBackendInfo(VideoConfig* config);
+void PopulateBackendInfoAdapters(VideoConfig* config,
+                                 const std::vector<MRCOwned<id<MTLDevice>>>& adapters);
+void PopulateBackendInfoFeatures(VideoConfig* config, id<MTLDevice> device);
+
+AbstractTextureFormat ToAbstract(MTLPixelFormat format);
+MTLPixelFormat FromAbstract(AbstractTextureFormat format);
+static inline bool HasStencil(AbstractTextureFormat format)
+{
+  return format == AbstractTextureFormat::D24_S8 || format == AbstractTextureFormat::D32F_S8;
+}
+
+std::optional<std::string> TranslateShaderToMSL(ShaderStage stage, std::string_view source);
+
+}  // namespace Util
+}  // namespace Metal

Source/Core/VideoBackends/Metal/MTLUtil.mm

@@ -0,0 +1,358 @@
+// Copyright 2022 Dolphin Emulator Project
+// SPDX-License-Identifier: GPL-2.0-or-later
+
+#include "VideoBackends/Metal/MTLUtil.h"
+
+#include <fstream>
+#include <string>
+
+#include <spirv_msl.hpp>
+
+#include "Common/MsgHandler.h"
+
+#include "VideoCommon/Spirv.h"
+
+Metal::DeviceFeatures Metal::g_features;
+
+std::vector<MRCOwned<id<MTLDevice>>> Metal::Util::GetAdapterList()
+{
+  std::vector<MRCOwned<id<MTLDevice>>> list;
+  id<MTLDevice> default_dev = MTLCreateSystemDefaultDevice();
+  if (default_dev)
+    list.push_back(MRCTransfer(default_dev));
+
+  auto devices = MRCTransfer(MTLCopyAllDevices());
+  for (id<MTLDevice> device in devices.Get())
+  {
+    if (device != default_dev)
+      list.push_back(MRCRetain(device));
+  }
+  return list;
+}
+
+void Metal::Util::PopulateBackendInfo(VideoConfig* config)
+{
+  config->backend_info.api_type = APIType::Metal;
+  config->backend_info.bUsesLowerLeftOrigin = false;
+  config->backend_info.bSupportsExclusiveFullscreen = false;
+  config->backend_info.bSupportsDualSourceBlend = true;
+  config->backend_info.bSupportsPrimitiveRestart = true;
+  config->backend_info.bSupportsGeometryShaders = false;
+  config->backend_info.bSupportsComputeShaders = true;
+  config->backend_info.bSupports3DVision = false;
+  config->backend_info.bSupportsEarlyZ = true;
+  config->backend_info.bSupportsBindingLayout = true;
+  config->backend_info.bSupportsBBox = true;
+  config->backend_info.bSupportsGSInstancing = false;
+  config->backend_info.bSupportsPostProcessing = true;
+  config->backend_info.bSupportsPaletteConversion = true;
+  config->backend_info.bSupportsClipControl = true;
+  config->backend_info.bSupportsSSAA = true;
+  config->backend_info.bSupportsFragmentStoresAndAtomics = true;
+  config->backend_info.bSupportsReversedDepthRange = false;
+  config->backend_info.bSupportsLogicOp = false;
+  config->backend_info.bSupportsMultithreading = false;
+  config->backend_info.bSupportsGPUTextureDecoding = true;
+  config->backend_info.bSupportsCopyToVram = true;
+  config->backend_info.bSupportsBitfield = true;
+  config->backend_info.bSupportsDynamicSamplerIndexing = true;
+  config->backend_info.bSupportsFramebufferFetch = false;
+  config->backend_info.bSupportsBackgroundCompiling = true;
+  config->backend_info.bSupportsLargePoints = true;
+  config->backend_info.bSupportsPartialDepthCopies = true;
+  config->backend_info.bSupportsDepthReadback = true;
+  config->backend_info.bSupportsShaderBinaries = false;
+  config->backend_info.bSupportsPipelineCacheData = false;
+  config->backend_info.bSupportsCoarseDerivatives = false;
+  config->backend_info.bSupportsTextureQueryLevels = true;
+  config->backend_info.bSupportsLodBiasInSampler = false;
+  config->backend_info.bSupportsSettingObjectNames = true;
+}
+
+void Metal::Util::PopulateBackendInfoAdapters(VideoConfig* config,
+                                              const std::vector<MRCOwned<id<MTLDevice>>>& adapters)
+{
+  config->backend_info.Adapters.clear();
+  for (id<MTLDevice> adapter : adapters)
+  {
+    config->backend_info.Adapters.push_back([[adapter name] UTF8String]);
+  }
+}
+
+void Metal::Util::PopulateBackendInfoFeatures(VideoConfig* config, id<MTLDevice> device)
+{
+#if TARGET_OS_OSX
+  config->backend_info.bSupportsDepthClamp = true;
+  config->backend_info.bSupportsST3CTextures = true;
+  config->backend_info.bSupportsBPTCTextures = true;
+#else
+  bool supports_mac1 = false;
+  bool supports_apple4 = false;
+  if (@available(iOS 13, *))
+  {
+    supports_mac1 = [device supportsFamily:MTLGPUFamilyMac1];
+    supports_apple4 = [device supportsFamily:MTLGPUFamilyApple4];
+  }
+  else
+  {
+    supports_apple4 = [device supportsFeatureSet:MTLFeatureSet_iOS_GPUFamily4_v1];
+  }
+  config->backend_info.bSupportsDepthClamp = supports_mac1 || supports_apple4;
+  config->backend_info.bSupportsST3CTextures = supports_mac1;
+  config->backend_info.bSupportsBPTCTextures = supports_mac1;
+  config->backend_info.bSupportsFramebufferFetch = true;
+#endif
+  if (char* env = getenv("MTL_UNIFIED_MEMORY"))
+    g_features.unified_memory = env[0] == '1' || env[0] == 'y' || env[0] == 'Y';
+  else if (@available(macOS 10.15, iOS 13.0, *))
+    g_features.unified_memory = [device hasUnifiedMemory];
+  else
+    g_features.unified_memory = false;
+
+  g_features.subgroup_ops = false;
+  if (@available(macOS 10.15, iOS 13, *))
+  {
+    // Requires SIMD-scoped reduction operations
+    g_features.subgroup_ops =
+        [device supportsFamily:MTLGPUFamilyMac2] || [device supportsFamily:MTLGPUFamilyApple6];
+    config->backend_info.bSupportsFramebufferFetch = [device supportsFamily:MTLGPUFamilyApple1];
+  }
+  if ([[device name] containsString:@"AMD"])
+  {
+    // Broken
+    g_features.subgroup_ops = false;
+  }
+}
+
+// clang-format off
+
+AbstractTextureFormat Metal::Util::ToAbstract(MTLPixelFormat format)
+{
+  switch (format)
+  {
+  case MTLPixelFormatRGBA8Unorm:            return AbstractTextureFormat::RGBA8;
+  case MTLPixelFormatBGRA8Unorm:            return AbstractTextureFormat::BGRA8;
+  case MTLPixelFormatBC1_RGBA:              return AbstractTextureFormat::DXT1;
+  case MTLPixelFormatBC2_RGBA:              return AbstractTextureFormat::DXT3;
+  case MTLPixelFormatBC3_RGBA:              return AbstractTextureFormat::DXT5;
+  case MTLPixelFormatBC7_RGBAUnorm:         return AbstractTextureFormat::BPTC;
+  case MTLPixelFormatR16Unorm:              return AbstractTextureFormat::R16;
+  case MTLPixelFormatDepth16Unorm:          return AbstractTextureFormat::D16;
+  case MTLPixelFormatDepth24Unorm_Stencil8: return AbstractTextureFormat::D24_S8;
+  case MTLPixelFormatR32Float:              return AbstractTextureFormat::R32F;
+  case MTLPixelFormatDepth32Float:          return AbstractTextureFormat::D32F;
+  case MTLPixelFormatDepth32Float_Stencil8: return AbstractTextureFormat::D32F_S8;
+  default:                                  return AbstractTextureFormat::Undefined;
+  }
+}
+
+MTLPixelFormat Metal::Util::FromAbstract(AbstractTextureFormat format)
+{
+  switch (format)
+  {
+  case AbstractTextureFormat::RGBA8:     return MTLPixelFormatRGBA8Unorm;
+  case AbstractTextureFormat::BGRA8:     return MTLPixelFormatBGRA8Unorm;
+  case AbstractTextureFormat::DXT1:      return MTLPixelFormatBC1_RGBA;
+  case AbstractTextureFormat::DXT3:      return MTLPixelFormatBC2_RGBA;
+  case AbstractTextureFormat::DXT5:      return MTLPixelFormatBC3_RGBA;
+  case AbstractTextureFormat::BPTC:      return MTLPixelFormatBC7_RGBAUnorm;
+  case AbstractTextureFormat::R16:       return MTLPixelFormatR16Unorm;
+  case AbstractTextureFormat::D16:       return MTLPixelFormatDepth16Unorm;
+  case AbstractTextureFormat::D24_S8:    return MTLPixelFormatDepth24Unorm_Stencil8;
+  case AbstractTextureFormat::R32F:      return MTLPixelFormatR32Float;
+  case AbstractTextureFormat::D32F:      return MTLPixelFormatDepth32Float;
+  case AbstractTextureFormat::D32F_S8:   return MTLPixelFormatDepth32Float_Stencil8;
+  case AbstractTextureFormat::Undefined: return MTLPixelFormatInvalid;
+  }
+}
+
+// clang-format on
+
+// MARK: Shader Translation
+
+static const std::string_view SHADER_HEADER = R"(
+// Target GLSL 4.5.
+#version 450 core
+// Always available on Metal
+#extension GL_EXT_shader_8bit_storage : require
+#extension GL_EXT_shader_16bit_storage : require
+#extension GL_EXT_shader_explicit_arithmetic_types_int8 : require
+#extension GL_EXT_shader_explicit_arithmetic_types_int16 : require
+
+#define ATTRIBUTE_LOCATION(x) layout(location = x)
+#define FRAGMENT_OUTPUT_LOCATION(x) layout(location = x)
+#define FRAGMENT_OUTPUT_LOCATION_INDEXED(x, y) layout(location = x, index = y)
+#define UBO_BINDING(packing, x) layout(packing, set = 0, binding = (x - 1))
+#define SAMPLER_BINDING(x) layout(set = 1, binding = x)
+#define TEXEL_BUFFER_BINDING(x) layout(set = 1, binding = (x + 8))
+#define SSBO_BINDING(x) layout(std430, set = 2, binding = x)
+#define INPUT_ATTACHMENT_BINDING(x, y, z) layout(set = x, binding = y, input_attachment_index = z)
+#define VARYING_LOCATION(x) layout(location = x)
+#define FORCE_EARLY_Z layout(early_fragment_tests) in
+
+// Metal framebuffer fetch helpers.
+#define FB_FETCH_VALUE subpassLoad(in_ocol0)
+
+// hlsl to glsl function translation
+#define API_METAL 1
+#define float2 vec2
+#define float3 vec3
+#define float4 vec4
+#define uint2 uvec2
+#define uint3 uvec3
+#define uint4 uvec4
+#define int2 ivec2
+#define int3 ivec3
+#define int4 ivec4
+#define frac fract
+#define lerp mix
+
+// These were changed in Vulkan
+#define gl_VertexID gl_VertexIndex
+#define gl_InstanceID gl_InstanceIndex
+)";
+static const std::string_view COMPUTE_SHADER_HEADER = R"(
+// Target GLSL 4.5.
+#version 450 core
+// Always available on Metal
+#extension GL_EXT_shader_8bit_storage : require
+#extension GL_EXT_shader_16bit_storage : require
+#extension GL_EXT_shader_explicit_arithmetic_types_int8 : require
+#extension GL_EXT_shader_explicit_arithmetic_types_int16 : require
+
+// All resources are packed into one descriptor set for compute.
+#define UBO_BINDING(packing, x) layout(packing, set = 0, binding = (x - 1))
+#define SSBO_BINDING(x) layout(std430, set = 2, binding = x)
+#define IMAGE_BINDING(format, x) layout(format, set = 1, binding = x)
+
+// hlsl to glsl function translation
+#define API_METAL 1
+#define float2 vec2
+#define float3 vec3
+#define float4 vec4
+#define uint2 uvec2
+#define uint3 uvec3
+#define uint4 uvec4
+#define int2 ivec2
+#define int3 ivec3
+#define int4 ivec4
+#define frac fract
+#define lerp mix
+)";
+static const std::string_view SUBGROUP_HELPER_HEADER = R"(
+#extension GL_KHR_shader_subgroup_basic : enable
+#extension GL_KHR_shader_subgroup_arithmetic : enable
+#extension GL_KHR_shader_subgroup_ballot : enable
+
+#define SUPPORTS_SUBGROUP_REDUCTION 1
+#define CAN_USE_SUBGROUP_REDUCTION true
+#define IS_HELPER_INVOCATION gl_HelperInvocation
+#define IS_FIRST_ACTIVE_INVOCATION (subgroupElect())
+#define SUBGROUP_MIN(value) value = subgroupMin(value)
+#define SUBGROUP_MAX(value) value = subgroupMax(value)
+)";
+
+static const std::string_view MSL_HEADER =
+    // We know our shader generator leaves unused variables.
+    "#pragma clang diagnostic ignored \"-Wunused-variable\"\n"
+    // These are usually when the compiler doesn't think a switch is exhaustive
+    "#pragma clang diagnostic ignored \"-Wreturn-type\"\n";
+
+static constexpr spirv_cross::MSLResourceBinding
+MakeResourceBinding(spv::ExecutionModel stage, u32 set, u32 binding,  //
+                    u32 msl_buffer, u32 msl_texture, u32 msl_sampler)
+{
+  spirv_cross::MSLResourceBinding resource;
+  resource.stage = stage;
+  resource.desc_set = set;
+  resource.binding = binding;
+  resource.msl_buffer = msl_buffer;
+  resource.msl_texture = msl_texture;
+  resource.msl_sampler = msl_sampler;
+  return resource;
+}
+
+std::optional<std::string> Metal::Util::TranslateShaderToMSL(ShaderStage stage,
+                                                             std::string_view source)
+{
+  std::string full_source;
+
+  std::string_view header = stage == ShaderStage::Compute ? COMPUTE_SHADER_HEADER : SHADER_HEADER;
+  full_source.reserve(header.size() + SUBGROUP_HELPER_HEADER.size() + source.size());
+
+  full_source.append(header);
+  if (Metal::g_features.subgroup_ops)
+    full_source.append(SUBGROUP_HELPER_HEADER);
+  full_source.append(source);
+
+  std::optional<SPIRV::CodeVector> code;
+  switch (stage)
+  {
+  case ShaderStage::Vertex:
+    code = SPIRV::CompileVertexShader(full_source, APIType::Metal, glslang::EShTargetSpv_1_3);
+    break;
+  case ShaderStage::Geometry:
+    PanicAlertFmt("Tried to compile geometry shader for Metal, but Metal doesn't support them!");
+    break;
+  case ShaderStage::Pixel:
+    code = SPIRV::CompileFragmentShader(full_source, APIType::Metal, glslang::EShTargetSpv_1_3);
+    break;
+  case ShaderStage::Compute:
+    code = SPIRV::CompileComputeShader(full_source, APIType::Metal, glslang::EShTargetSpv_1_3);
+    break;
+  }
+  if (!code.has_value())
+    return std::nullopt;
+
+  // clang-format off
+  static const spirv_cross::MSLResourceBinding resource_bindings[] = {
+      MakeResourceBinding(spv::ExecutionModelVertex,    0, 0, 1, 0, 0), // vs/ubo
+      MakeResourceBinding(spv::ExecutionModelVertex,    0, 1, 1, 0, 0), // vs/ubo
+      MakeResourceBinding(spv::ExecutionModelFragment,  0, 0, 0, 0, 0), // vs/ubo
+      MakeResourceBinding(spv::ExecutionModelFragment,  0, 1, 1, 0, 0), // vs/ubo
+      MakeResourceBinding(spv::ExecutionModelFragment,  1, 0, 0, 0, 0), // ps/samp0
+      MakeResourceBinding(spv::ExecutionModelFragment,  1, 1, 0, 1, 1), // ps/samp1
+      MakeResourceBinding(spv::ExecutionModelFragment,  1, 2, 0, 2, 2), // ps/samp2
+      MakeResourceBinding(spv::ExecutionModelFragment,  1, 3, 0, 3, 3), // ps/samp3
+      MakeResourceBinding(spv::ExecutionModelFragment,  1, 4, 0, 4, 4), // ps/samp4
+      MakeResourceBinding(spv::ExecutionModelFragment,  1, 5, 0, 5, 5), // ps/samp5
+      MakeResourceBinding(spv::ExecutionModelFragment,  1, 6, 0, 6, 6), // ps/samp6
+      MakeResourceBinding(spv::ExecutionModelFragment,  1, 7, 0, 7, 7), // ps/samp7
+      MakeResourceBinding(spv::ExecutionModelFragment,  1, 8, 0, 8, 8), // ps/samp8
+      MakeResourceBinding(spv::ExecutionModelFragment,  2, 0, 2, 0, 0), // ps/ssbo
+      MakeResourceBinding(spv::ExecutionModelGLCompute, 0, 1, 0, 0, 0), // cs/ubo
+      MakeResourceBinding(spv::ExecutionModelGLCompute, 1, 0, 0, 0, 0), // cs/output_image
+      MakeResourceBinding(spv::ExecutionModelGLCompute, 2, 0, 2, 0, 0), // cs/ssbo
+      MakeResourceBinding(spv::ExecutionModelGLCompute, 2, 1, 3, 0, 0), // cs/ssbo
+  };
+
+  spirv_cross::CompilerMSL::Options options;
+#if TARGET_OS_OSX
+  options.platform = spirv_cross::CompilerMSL::Options::macOS;
+#elif TARGET_OS_IOS
+  options.platform = spirv_cross::CompilerMSL::Options::iOS;
+#else
+  #error What platform is this?
+#endif
+  // clang-format on
+
+  spirv_cross::CompilerMSL compiler(std::move(*code));
+
+  if (@available(macOS 11, iOS 14, *))
+    options.set_msl_version(2, 3);
+  else if (@available(macOS 10.15, iOS 13, *))
+    options.set_msl_version(2, 2);
+  else if (@available(macOS 10.14, iOS 12, *))
+    options.set_msl_version(2, 1);
+  else
+    options.set_msl_version(2, 0);
+  options.use_framebuffer_fetch_subpasses = true;
+  compiler.set_msl_options(options);
+
+  for (auto& binding : resource_bindings)
+    compiler.add_msl_resource_binding(binding);
+
+  std::string msl(MSL_HEADER);
+  msl += compiler.compile();
+  return msl;
+}

Source/Core/VideoBackends/Metal/MTLVertexManager.h

@@ -0,0 +1,30 @@
+// Copyright 2022 Dolphin Emulator Project
+// SPDX-License-Identifier: GPL-2.0-or-later
+
+#pragma once
+
+#include "VideoBackends/Metal/MTLUtil.h"
+#include "VideoCommon/VertexManagerBase.h"
+
+namespace Metal
+{
+class VertexManager final : public VertexManagerBase
+{
+public:
+  VertexManager();
+  ~VertexManager() override;
+
+  void UploadUtilityUniforms(const void* uniforms, u32 uniforms_size) override;
+  bool UploadTexelBuffer(const void* data, u32 data_size, TexelBufferFormat format,
+                         u32* out_offset) override;
+  bool UploadTexelBuffer(const void* data, u32 data_size, TexelBufferFormat format, u32* out_offset,
+                         const void* palette_data, u32 palette_size,
+                         TexelBufferFormat palette_format, u32* out_palette_offset) override;
+
+protected:
+  void ResetBuffer(u32 vertex_stride) override;
+  void CommitBuffer(u32 num_vertices, u32 vertex_stride, u32 num_indices, u32* out_base_vertex,
+                    u32* out_base_index) override;
+  void UploadUniforms() override;
+};
+}  // namespace Metal

Source/Core/VideoBackends/Metal/MTLVertexManager.mm

@@ -0,0 +1,89 @@
+// Copyright 2022 Dolphin Emulator Project
+// SPDX-License-Identifier: GPL-2.0-or-later
+
+#include "VideoBackends/Metal/MTLVertexManager.h"
+
+#include "VideoBackends/Metal/MTLStateTracker.h"
+
+#include "VideoCommon/PixelShaderManager.h"
+#include "VideoCommon/Statistics.h"
+#include "VideoCommon/VertexShaderManager.h"
+
+Metal::VertexManager::VertexManager()
+{
+}
+
+Metal::VertexManager::~VertexManager() = default;
+
+void Metal::VertexManager::UploadUtilityUniforms(const void* uniforms, u32 uniforms_size)
+{
+  g_state_tracker->SetUtilityUniform(uniforms, uniforms_size);
+}
+
+bool Metal::VertexManager::UploadTexelBuffer(const void* data, u32 data_size,
+                                             TexelBufferFormat format, u32* out_offset)
+{
+  *out_offset = 0;
+  StateTracker::Map map = g_state_tracker->Allocate(StateTracker::UploadBuffer::Texels, data_size,
+                                                    StateTracker::AlignMask::Other);
+  memcpy(map.cpu_buffer, data, data_size);
+  g_state_tracker->SetTexelBuffer(map.gpu_buffer, map.gpu_offset, 0);
+  return true;
+}
+
+bool Metal::VertexManager::UploadTexelBuffer(const void* data, u32 data_size,
+                                             TexelBufferFormat format, u32* out_offset,
+                                             const void* palette_data, u32 palette_size,
+                                             TexelBufferFormat palette_format,
+                                             u32* out_palette_offset)
+{
+  *out_offset = 0;
+  *out_palette_offset = 0;
+
+  const u32 aligned_data_size = g_state_tracker->Align(data_size, StateTracker::AlignMask::Other);
+  const u32 total_size = aligned_data_size + palette_size;
+  StateTracker::Map map = g_state_tracker->Allocate(StateTracker::UploadBuffer::Texels, total_size,
+                                                    StateTracker::AlignMask::Other);
+  memcpy(map.cpu_buffer, data, data_size);
+  memcpy(static_cast<char*>(map.cpu_buffer) + aligned_data_size, palette_data, palette_size);
+  g_state_tracker->SetTexelBuffer(map.gpu_buffer, map.gpu_offset,
+                                  map.gpu_offset + aligned_data_size);
+  return true;
+}
+
+void Metal::VertexManager::ResetBuffer(u32 vertex_stride)
+{
+  const u32 max_vertex_size = 65535 * vertex_stride;
+  void* vertex = g_state_tracker->Preallocate(StateTracker::UploadBuffer::Vertex, max_vertex_size);
+  void* index =
+      g_state_tracker->Preallocate(StateTracker::UploadBuffer::Index, MAXIBUFFERSIZE * sizeof(u16));
+
+  m_cur_buffer_pointer = m_base_buffer_pointer = static_cast<u8*>(vertex);
+  m_end_buffer_pointer = m_base_buffer_pointer + max_vertex_size;
+  m_index_generator.Start(static_cast<u16*>(index));
+}
+
+void Metal::VertexManager::CommitBuffer(u32 num_vertices, u32 vertex_stride, u32 num_indices,
+                                        u32* out_base_vertex, u32* out_base_index)
+{
+  const u32 vsize = num_vertices * vertex_stride;
+  const u32 isize = num_indices * sizeof(u16);
+  StateTracker::Map vmap = g_state_tracker->CommitPreallocation(
+      StateTracker::UploadBuffer::Vertex, vsize, StateTracker::AlignMask::Other);
+  StateTracker::Map imap = g_state_tracker->CommitPreallocation(
+      StateTracker::UploadBuffer::Index, isize, StateTracker::AlignMask::Other);
+
+  ADDSTAT(g_stats.this_frame.bytes_vertex_streamed, vsize);
+  ADDSTAT(g_stats.this_frame.bytes_index_streamed, isize);
+
+  g_state_tracker->SetVerticesAndIndices(vmap, imap);
+  *out_base_vertex = 0;
+  *out_base_index = 0;
+}
+
+void Metal::VertexManager::UploadUniforms()
+{
+  g_state_tracker->InvalidateUniforms(VertexShaderManager::dirty, PixelShaderManager::dirty);
+  VertexShaderManager::dirty = false;
+  PixelShaderManager::dirty = false;
+}

Source/Core/VideoBackends/Metal/VideoBackend.h

@@ -0,0 +1,27 @@
+// Copyright 2022 Dolphin Emulator Project
+// SPDX-License-Identifier: GPL-2.0-or-later
+
+#pragma once
+
+#include <string>
+#include "VideoCommon/VideoBackendBase.h"
+
+namespace Metal
+{
+class VideoBackend : public VideoBackendBase
+{
+public:
+  bool Initialize(const WindowSystemInfo& wsi) override;
+  void Shutdown() override;
+
+  std::string GetName() const override;
+  std::string GetDisplayName() const override;
+  std::optional<std::string> GetWarningMessage() const override;
+
+  void InitBackendInfo() override;
+
+  void PrepareWindow(WindowSystemInfo& wsi) override;
+
+  static constexpr const char* NAME = "Metal";
+};
+}  // namespace Metal

Source/Core/VideoBackends/OGL/OGLRender.cpp

@@ -903,8 +903,8 @@ void Renderer::DrawIndexed(u32 base_index, u32 num_indices, u32 base_vertex)
   }
 }
 
-void Renderer::DispatchComputeShader(const AbstractShader* shader, u32 groups_x, u32 groups_y,
+void Renderer::DispatchComputeShader(const AbstractShader* shader, u32 groupsize_x, u32 groupsize_y,
-                                     u32 groups_z)
+                                     u32 groupsize_z, u32 groups_x, u32 groups_y, u32 groups_z)
 {
   glUseProgram(static_cast<const OGLShader*>(shader)->GetGLComputeProgramID());
   glDispatchCompute(groups_x, groups_y, groups_z);

Source/Core/VideoBackends/OGL/OGLRender.h

@@ -125,8 +125,8 @@ public:
                    float far_depth) override;
   void Draw(u32 base_vertex, u32 num_vertices) override;
   void DrawIndexed(u32 base_index, u32 num_indices, u32 base_vertex) override;
-  void DispatchComputeShader(const AbstractShader* shader, u32 groups_x, u32 groups_y,
+  void DispatchComputeShader(const AbstractShader* shader, u32 groupsize_x, u32 groupsize_y,
-                             u32 groups_z) override;
+                             u32 groupsize_z, u32 groups_x, u32 groups_y, u32 groups_z) override;
   void BindBackbuffer(const ClearColor& clear_color = {}) override;
   void PresentBackbuffer() override;
 

Source/Core/VideoBackends/Vulkan/VKRenderer.cpp

@@ -641,8 +641,8 @@ void Renderer::DrawIndexed(u32 base_index, u32 num_indices, u32 base_vertex)
                    base_vertex, 0);
 }
 
-void Renderer::DispatchComputeShader(const AbstractShader* shader, u32 groups_x, u32 groups_y,
+void Renderer::DispatchComputeShader(const AbstractShader* shader, u32 groupsize_x, u32 groupsize_y,
-                                     u32 groups_z)
+                                     u32 groupsize_z, u32 groups_x, u32 groups_y, u32 groups_z)
 {
   StateTracker::GetInstance()->SetComputeShader(static_cast<const VKShader*>(shader));
   if (StateTracker::GetInstance()->BindCompute())

Source/Core/VideoBackends/Vulkan/VKRenderer.h

@@ -77,8 +77,8 @@ public:
                    float far_depth) override;
   void Draw(u32 base_vertex, u32 num_vertices) override;
   void DrawIndexed(u32 base_index, u32 num_indices, u32 base_vertex) override;
-  void DispatchComputeShader(const AbstractShader* shader, u32 groups_x, u32 groups_y,
+  void DispatchComputeShader(const AbstractShader* shader, u32 groupsize_x, u32 groupsize_y,
-                             u32 groups_z) override;
+                             u32 groupsize_z, u32 groups_x, u32 groups_y, u32 groups_z) override;
   void BindBackbuffer(const ClearColor& clear_color = {}) override;
   void PresentBackbuffer() override;
   void SetFullscreen(bool enable_fullscreen) override;

Source/Core/VideoCommon/FramebufferShaderGen.cpp

@@ -34,6 +34,7 @@ void EmitSamplerDeclarations(ShaderCode& code, u32 start = 0, u32 end = 1,
   switch (GetAPIType())
   {
   case APIType::D3D:
+  case APIType::Metal:
   case APIType::OpenGL:
   case APIType::Vulkan:
   {
@@ -55,6 +56,7 @@ void EmitSampleTexture(ShaderCode& code, u32 n, std::string_view coords)
   switch (GetAPIType())
   {
   case APIType::D3D:
+  case APIType::Metal:
   case APIType::OpenGL:
   case APIType::Vulkan:
     code.Write("texture(samp{}, {})", n, coords);
@@ -72,6 +74,7 @@ void EmitTextureLoad(ShaderCode& code, u32 n, std::string_view coords)
   switch (GetAPIType())
   {
   case APIType::D3D:
+  case APIType::Metal:
   case APIType::OpenGL:
   case APIType::Vulkan:
     code.Write("texelFetch(samp{}, ({}).xyz, ({}).w)", n, coords, coords);
@@ -89,6 +92,7 @@ void EmitVertexMainDeclaration(ShaderCode& code, u32 num_tex_inputs, u32 num_col
   switch (GetAPIType())
   {
   case APIType::D3D:
+  case APIType::Metal:
   case APIType::OpenGL:
   case APIType::Vulkan:
   {
@@ -138,6 +142,7 @@ void EmitPixelMainDeclaration(ShaderCode& code, u32 num_tex_inputs, u32 num_colo
   switch (GetAPIType())
   {
   case APIType::D3D:
+  case APIType::Metal:
   case APIType::OpenGL:
   case APIType::Vulkan:
   {

Source/Core/VideoCommon/RenderBase.h

@@ -113,8 +113,8 @@ public:
   virtual void DrawIndexed(u32 base_index, u32 num_indices, u32 base_vertex) {}
 
   // Dispatching compute shaders with currently-bound state.
-  virtual void DispatchComputeShader(const AbstractShader* shader, u32 groups_x, u32 groups_y,
+  virtual void DispatchComputeShader(const AbstractShader* shader, u32 groupsize_x, u32 groupsize_y,
-                                     u32 groups_z)
+                                     u32 groupsize_z, u32 groups_x, u32 groups_y, u32 groups_z)
   {
   }
 

Source/Core/VideoCommon/ShaderGenCommon.cpp

@@ -60,6 +60,9 @@ std::string GetDiskShaderCacheFileName(APIType api_type, const char* type, bool
     case APIType::D3D:
       filename += "D3D";
       break;
+    case APIType::Metal:
+      filename += "Metal";
+      break;
     case APIType::OpenGL:
       filename += "OpenGL";
       break;

Source/Core/VideoCommon/Spirv.cpp

@@ -55,7 +55,7 @@ CompileShaderToSPV(EShLanguage stage, APIType api_type,
   glslang::TShader::ForbidIncluder includer;
   EProfile profile = ECoreProfile;
   EShMessages messages = static_cast<EShMessages>(EShMsgDefault | EShMsgSpvRules);
-  if (api_type == APIType::Vulkan)
+  if (api_type == APIType::Vulkan || api_type == APIType::Metal)
     messages = static_cast<EShMessages>(messages | EShMsgVulkanRules);
   int default_version = 450;
 

Source/Core/VideoCommon/TextureCacheBase.cpp

@@ -2924,7 +2924,8 @@ bool TextureCacheBase::DecodeTextureOnGPU(TCacheEntry* entry, u32 dst_level, con
 
   auto dispatch_groups =
       TextureConversionShaderTiled::GetDispatchCount(info, aligned_width, aligned_height);
-  g_renderer->DispatchComputeShader(shader, dispatch_groups.first, dispatch_groups.second, 1);
+  g_renderer->DispatchComputeShader(shader, info->group_size_x, info->group_size_y, 1,
+                                    dispatch_groups.first, dispatch_groups.second, 1);
 
   // Copy from decoding texture -> final texture
   // This is because we don't want to have to create compute view for every layer

Source/Core/VideoCommon/TextureConversionShader.cpp

@@ -519,10 +519,49 @@ UBO_BINDING(std140, 1) uniform UBO {
   uint u_palette_offset;
 };
 
-TEXEL_BUFFER_BINDING(0) uniform usamplerBuffer s_input_buffer;
+#if defined(API_METAL)
-#ifdef HAS_PALETTE
+
-TEXEL_BUFFER_BINDING(1) uniform usamplerBuffer s_palette_buffer;
+#if defined(TEXEL_BUFFER_FORMAT_R8)
+  SSBO_BINDING(0) readonly buffer Input { uint8_t s_input_buffer[]; };
+  #define FETCH(offset) uint(s_input_buffer[offset])
+#elif defined(TEXEL_BUFFER_FORMAT_R16)
+  SSBO_BINDING(0) readonly buffer Input { uint16_t s_input_buffer[]; };
+  #define FETCH(offset) uint(s_input_buffer[offset])
+#elif defined(TEXEL_BUFFER_FORMAT_RGBA8)
+  SSBO_BINDING(0) readonly buffer Input { u8vec4 s_input_buffer[]; };
+  #define FETCH(offset) uvec4(s_input_buffer[offset])
+#elif defined(TEXEL_BUFFER_FORMAT_R32G32)
+  SSBO_BINDING(0) readonly buffer Input { uvec2 s_input_buffer[]; };
+  #define FETCH(offset) s_input_buffer[offset]
+#else
+  #error No texel buffer?
 #endif
+
+#ifdef HAS_PALETTE
+  SSBO_BINDING(1) readonly buffer Palette { uint16_t s_palette_buffer[]; };
+  #define FETCH_PALETTE(offset) uint(s_palette_buffer[offset])
+#endif
+
+#else
+
+TEXEL_BUFFER_BINDING(0) uniform usamplerBuffer s_input_buffer;
+
+#if defined(TEXEL_BUFFER_FORMAT_R8) || defined(TEXEL_BUFFER_FORMAT_R16)
+  #define FETCH(offset) texelFetch(s_input_buffer, int((offset) + u_src_offset)).r
+#elif defined(TEXEL_BUFFER_FORMAT_RGBA8)
+  #define FETCH(offset) texelFetch(s_input_buffer, int((offset) + u_src_offset))
+#elif defined(TEXEL_BUFFER_FORMAT_R32G32)
+  #define FETCH(offset) texelFetch(s_input_buffer, int((offset) + u_src_offset)).rg
+#else
+  #error No texel buffer?
+#endif
+
+#ifdef HAS_PALETTE
+  TEXEL_BUFFER_BINDING(1) uniform usamplerBuffer s_palette_buffer;
+  #define FETCH_PALETTE(offset) texelFetch(s_palette_buffer, int((offset) + u_palette_offset)).r
+#endif
+
+#endif // defined(API_METAL)
 IMAGE_BINDING(rgba8, 0) uniform writeonly image2DArray output_image;
 
 #define GROUP_MEMORY_BARRIER_WITH_SYNC memoryBarrierShared(); barrier();
@@ -563,7 +602,7 @@ uint GetTiledTexelOffset(uint2 block_size, uint2 coords)
 {
   uint2 block = coords / block_size;
   uint2 offset = coords % block_size;
-  uint buffer_pos = u_src_offset;
+  uint buffer_pos = 0;
   buffer_pos += block.y * u_src_row_stride;
   buffer_pos += block.x * (block_size.x * block_size.y);
   buffer_pos += offset.y * block_size.x;
@@ -575,7 +614,7 @@ uint GetTiledTexelOffset(uint2 block_size, uint2 coords)
 uint4 GetPaletteColor(uint index)
 {
   // Fetch and swap BE to LE.
-  uint val = Swap16(texelFetch(s_palette_buffer, int(u_palette_offset + index)).x);
+  uint val = Swap16(FETCH_PALETTE(index));
 
   uint4 color;
 #if defined(PALETTE_FORMAT_IA8)
@@ -633,14 +672,14 @@ static const std::map<TextureFormat, DecodingShaderInfo> s_decoding_shader_info{
         // the size of the buffer elements.
         uint2 block = coords.xy / 8u;
         uint2 offset = coords.xy % 8u;
-        uint buffer_pos = u_src_offset;
+        uint buffer_pos = 0;
         buffer_pos += block.y * u_src_row_stride;
         buffer_pos += block.x * 32u;
         buffer_pos += offset.y * 4u;
         buffer_pos += offset.x / 2u;
 
         // Select high nibble for odd texels, low for even.
-        uint val = texelFetch(s_input_buffer, int(buffer_pos)).x;
+        uint val = FETCH(buffer_pos);
         uint i;
         if ((coords.x & 1u) == 0u)
           i = Convert4To8((val >> 4));
@@ -663,7 +702,7 @@ static const std::map<TextureFormat, DecodingShaderInfo> s_decoding_shader_info{
 
         // Tiled in 8x4 blocks, 8 bits per pixel
         uint buffer_pos = GetTiledTexelOffset(uint2(8u, 4u), coords);
-        uint val = texelFetch(s_input_buffer, int(buffer_pos)).x;
+        uint val = FETCH(buffer_pos);
         uint i = Convert4To8((val & 0x0Fu));
         uint a = Convert4To8((val >> 4));
         uint4 color = uint4(i, i, i, a);
@@ -681,7 +720,7 @@ static const std::map<TextureFormat, DecodingShaderInfo> s_decoding_shader_info{
 
         // Tiled in 8x4 blocks, 8 bits per pixel
         uint buffer_pos = GetTiledTexelOffset(uint2(8u, 4u), coords);
-        uint i = texelFetch(s_input_buffer, int(buffer_pos)).x;
+        uint i = FETCH(buffer_pos);
         uint4 color = uint4(i, i, i, i);
         float4 norm_color = float4(color) / 255.0;
 
@@ -697,7 +736,7 @@ static const std::map<TextureFormat, DecodingShaderInfo> s_decoding_shader_info{
 
         // Tiled in 4x4 blocks, 16 bits per pixel
         uint buffer_pos = GetTiledTexelOffset(uint2(4u, 4u), coords);
-        uint val = texelFetch(s_input_buffer, int(buffer_pos)).x;
+        uint val = FETCH(buffer_pos);
         uint a = (val & 0xFFu);
         uint i = (val >> 8);
         uint4 color = uint4(i, i, i, a);
@@ -714,7 +753,7 @@ static const std::map<TextureFormat, DecodingShaderInfo> s_decoding_shader_info{
 
         // Tiled in 4x4 blocks
         uint buffer_pos = GetTiledTexelOffset(uint2(4u, 4u), coords);
-        uint val = Swap16(texelFetch(s_input_buffer, int(buffer_pos)).x);
+        uint val = Swap16(FETCH(buffer_pos));
 
         uint4 color;
         color.x = Convert5To8(bitfieldExtract(val, 11, 5));
@@ -736,7 +775,7 @@ static const std::map<TextureFormat, DecodingShaderInfo> s_decoding_shader_info{
 
         // Tiled in 4x4 blocks
         uint buffer_pos = GetTiledTexelOffset(uint2(4u, 4u), coords);
-        uint val = Swap16(texelFetch(s_input_buffer, int(buffer_pos)).x);
+        uint val = Swap16(FETCH(buffer_pos));
 
         uint4 color;
         if ((val & 0x8000u) != 0u)
@@ -771,7 +810,7 @@ static const std::map<TextureFormat, DecodingShaderInfo> s_decoding_shader_info{
         // for the entire block, then the GB channels afterwards.
         uint2 block = coords.xy / 4u;
         uint2 offset = coords.xy % 4u;
-        uint buffer_pos = u_src_offset;
+        uint buffer_pos = 0;
 
         // Our buffer has 16-bit elements, so the offsets here are half what they would be in bytes.
         buffer_pos += block.y * u_src_row_stride;
@@ -780,8 +819,8 @@ static const std::map<TextureFormat, DecodingShaderInfo> s_decoding_shader_info{
         buffer_pos += offset.x;
 
         // The two GB channels follow after the block's AR channels.
-        uint val1 = texelFetch(s_input_buffer, int(buffer_pos + 0u)).x;
+        uint val1 = FETCH(buffer_pos +  0u);
-        uint val2 = texelFetch(s_input_buffer, int(buffer_pos + 16u)).x;
+        uint val2 = FETCH(buffer_pos + 16u);
 
         uint4 color;
         color.a = (val1 & 0xFFu);
@@ -835,14 +874,14 @@ static const std::map<TextureFormat, DecodingShaderInfo> s_decoding_shader_info{
           // Calculate tiled block coordinates.
           uint2 tile_block_coords = block_coords / 2u;
           uint2 subtile_block_coords = block_coords % 2u;
-          uint buffer_pos = u_src_offset;
+          uint buffer_pos = 0;
           buffer_pos += tile_block_coords.y * u_src_row_stride;
           buffer_pos += tile_block_coords.x * 4u;
           buffer_pos += subtile_block_coords.y * 2u;
           buffer_pos += subtile_block_coords.x;
 
           // Read the entire DXT block to shared memory.
-          uint2 raw_data = texelFetch(s_input_buffer, int(buffer_pos)).xy;
+          uint2 raw_data = FETCH(buffer_pos);
           shared_temp[block_in_group] = raw_data;
         }
 
@@ -921,14 +960,14 @@ static const std::map<TextureFormat, DecodingShaderInfo> s_decoding_shader_info{
         // the size of the buffer elements.
         uint2 block = coords.xy / 8u;
         uint2 offset = coords.xy % 8u;
-        uint buffer_pos = u_src_offset;
+        uint buffer_pos = 0;
         buffer_pos += block.y * u_src_row_stride;
         buffer_pos += block.x * 32u;
         buffer_pos += offset.y * 4u;
         buffer_pos += offset.x / 2u;
 
         // Select high nibble for odd texels, low for even.
-        uint val = texelFetch(s_input_buffer, int(buffer_pos)).x;
+        uint val = FETCH(buffer_pos);
         uint index = ((coords.x & 1u) == 0u) ? (val >> 4) : (val & 0x0Fu);
         float4 norm_color = GetPaletteColorNormalized(index);
         imageStore(output_image, int3(int2(coords), 0), norm_color);
@@ -945,7 +984,7 @@ static const std::map<TextureFormat, DecodingShaderInfo> s_decoding_shader_info{
 
         // Tiled in 8x4 blocks, 8 bits per pixel
         uint buffer_pos = GetTiledTexelOffset(uint2(8u, 4u), coords);
-        uint index = texelFetch(s_input_buffer, int(buffer_pos)).x;
+        uint index = FETCH(buffer_pos);
         float4 norm_color = GetPaletteColorNormalized(index);
         imageStore(output_image, int3(int2(coords), 0), norm_color);
       }
@@ -960,7 +999,7 @@ static const std::map<TextureFormat, DecodingShaderInfo> s_decoding_shader_info{
 
         // Tiled in 4x4 blocks, 16 bits per pixel
         uint buffer_pos = GetTiledTexelOffset(uint2(4u, 4u), coords);
-        uint index = Swap16(texelFetch(s_input_buffer, int(buffer_pos)).x) & 0x3FFFu;
+        uint index = Swap16(FETCH(buffer_pos)) & 0x3FFFu;
         float4 norm_color = GetPaletteColorNormalized(index);
         imageStore(output_image, int3(int2(coords), 0), norm_color);
       }
@@ -976,8 +1015,8 @@ static const std::map<TextureFormat, DecodingShaderInfo> s_decoding_shader_info{
       DEFINE_MAIN(8, 8)
       {
         uint2 uv = gl_GlobalInvocationID.xy;
-        int buffer_pos = int(u_src_offset + (uv.y * u_src_row_stride) + (uv.x / 2u));
+        uint buffer_pos = (uv.y * u_src_row_stride) + (uv.x / 2u);
-        float4 yuyv = float4(texelFetch(s_input_buffer, buffer_pos));
+        float4 yuyv = float4(FETCH(buffer_pos));
 
         float y = (uv.x & 1u) != 0u ? yuyv.b : yuyv.r;
 
@@ -1034,6 +1073,25 @@ std::string GenerateDecodingShader(TextureFormat format, std::optional<TLUTForma
     }
   }
 
+  switch (info->buffer_format)
+  {
+  case TEXEL_BUFFER_FORMAT_R8_UINT:
+    ss << "#define TEXEL_BUFFER_FORMAT_R8 1\n";
+    break;
+  case TEXEL_BUFFER_FORMAT_R16_UINT:
+    ss << "#define TEXEL_BUFFER_FORMAT_R16 1\n";
+    break;
+  case TEXEL_BUFFER_FORMAT_RGBA8_UINT:
+    ss << "#define TEXEL_BUFFER_FORMAT_RGBA8 1\n";
+    break;
+  case TEXEL_BUFFER_FORMAT_R32G32_UINT:
+    ss << "#define TEXEL_BUFFER_FORMAT_R32G32 1\n";
+    break;
+  case NUM_TEXEL_BUFFER_FORMATS:
+    ASSERT(0);
+    break;
+  }
+
   ss << decoding_shader_header;
   ss << info->shader_body;
 
@@ -1121,7 +1179,10 @@ float4 DecodePixel(int val)
 
   ss << "\n";
 
-  ss << "TEXEL_BUFFER_BINDING(0) uniform usamplerBuffer samp0;\n";
+  if (api_type == APIType::Metal)
+    ss << "SSBO_BINDING(0) readonly buffer Palette { uint16_t palette[]; };\n";
+  else
+    ss << "TEXEL_BUFFER_BINDING(0) uniform usamplerBuffer samp0;\n";
   ss << "SAMPLER_BINDING(1) uniform sampler2DArray samp1;\n";
   ss << "UBO_BINDING(std140, 1) uniform PSBlock {\n";
 
@@ -1143,9 +1204,12 @@ float4 DecodePixel(int val)
   ss << "void main() {\n";
   ss << "  float3 coords = v_tex0;\n";
   ss << "  int src = int(round(texture(samp1, coords).r * multiplier));\n";
-  ss << "  src = int(texelFetch(samp0, src + texel_buffer_offset).r);\n";
+  if (api_type == APIType::Metal)
+    ss << "  src = int(palette[uint(src)]);\n";
+  else
+    ss << "  src = int(texelFetch(samp0, src + texel_buffer_offset).r);\n";
 
-  ss << "  src = ((src << 8) & 0xFF00) | (src >> 8);\n";
+  ss << "  src = ((src << 8) | (src >> 8)) & 0xFFFF;\n";
   ss << "  ocol0 = DecodePixel(src);\n";
   ss << "}\n";
 

Source/Core/VideoCommon/UberShaderPixel.cpp

@@ -82,7 +82,7 @@ ShaderCode GenPixelShader(APIType api_type, const ShaderHostConfig& host_config,
 #ifdef __APPLE__
   // Framebuffer fetch is only supported by Metal, so ensure that we're running Vulkan (MoltenVK)
   // if we want to use it.
-  if (api_type == APIType::Vulkan)
+  if (api_type == APIType::Vulkan || api_type == APIType::Metal)
   {
     if (use_dual_source)
     {

Source/Core/VideoCommon/VideoBackendBase.cpp

@@ -35,6 +35,9 @@
 #ifdef HAS_VULKAN
 #include "VideoBackends/Vulkan/VideoBackend.h"
 #endif
+#ifdef __APPLE__
+#include "VideoBackends/Metal/VideoBackend.h"
+#endif
 
 #include "VideoCommon/AsyncRequests.h"
 #include "VideoCommon/BPStructs.h"
@@ -227,6 +230,7 @@ const std::vector<std::unique_ptr<VideoBackendBase>>& VideoBackendBase::GetAvail
 #ifdef __APPLE__
     // Emplace the Vulkan backend at the beginning so it takes precedence over OpenGL.
     backends.emplace(backends.begin(), std::make_unique<Vulkan::VideoBackend>());
+    backends.push_back(std::make_unique<Metal::VideoBackend>());
 #else
     backends.push_back(std::make_unique<Vulkan::VideoBackend>());
 #endif

Source/Core/VideoCommon/VideoCommon.h

@@ -39,6 +39,7 @@ enum class APIType
   OpenGL,
   D3D,
   Vulkan,
+  Metal,
   Nothing
 };