// Copyright 2010 Dolphin Emulator Project
// SPDX-License-Identifier: GPL-2.0-or-later

#include "VideoCommon/VertexManagerBase.h"

#include <array>
#include <cmath>
#include <memory>
#include <optional>
#include <string>

#include "Common/ChunkFile.h"
#include "Common/CommonTypes.h"
#include "Common/Contains.h"
#include "Common/EnumMap.h"
#include "Common/Logging/Log.h"
#include "Common/MathUtil.h"
#include "Common/SmallVector.h"

#include "Core/DolphinAnalytics.h"
#include "Core/HW/SystemTimers.h"
#include "Core/System.h"

#include "VideoCommon/AbstractGfx.h"
#include "VideoCommon/BPMemory.h"
#include "VideoCommon/BoundingBox.h"
#include "VideoCommon/DataReader.h"
#include "VideoCommon/ElementsGroupManager.h"
#include "VideoCommon/FramebufferManager.h"
#include "VideoCommon/GeometryShaderManager.h"
#include "VideoCommon/GraphicsModSystem/Runtime/CustomShaderCache.h"
#include "VideoCommon/GraphicsModSystem/Runtime/GraphicsModActionData.h"
#include "VideoCommon/GraphicsModSystem/Runtime/GraphicsModManager.h"
#include "VideoCommon/IndexGenerator.h"
#include "VideoCommon/MetroidElementClassifier.h"
#include "VideoCommon/NativeVertexFormat.h"
#include "VideoCommon/OpcodeDecoding.h"
#include "VideoCommon/PerfQueryBase.h"
#include "VideoCommon/PixelShaderGen.h"
#include "VideoCommon/PixelShaderManager.h"
#include "VideoCommon/Statistics.h"
#include "VideoCommon/TextureCacheBase.h"
#include "VideoCommon/VertexLoaderManager.h"
#include "VideoCommon/VertexShaderManager.h"
#include "VideoCommon/VideoBackendBase.h"
#include "VideoCommon/VideoCommon.h"
#include "VideoCommon/VR/OpenXRManager.h"
#include "VideoCommon/VideoConfig.h"
#include "VideoCommon/XFMemory.h"
#include "VideoCommon/CullingCodeFinder.h"
#include "VideoCommon/HideObjectEngine.h"
#include "VideoCommon/ShaderHunter.h"
#include "VideoCommon/TextureElementManager.h"
#include "VideoCommon/XFStateManager.h"

#include "Common/Hash.h"
#include "Core/ConfigManager.h"

std::unique_ptr<VertexManagerBase> g_vertex_manager;

using OpcodeDecoder::Primitive;

namespace
{
struct MetroidLayerBehavior
{
  bool skip = false;
  ShaderHunter::HandlingType handling = ShaderHunter::HandlingType::Skip;
};

struct MetroidHydraHudSettings
{
  bool enabled = false;
  bool perspective_hud = false;
  float scale = 1.0f;
  float width = 1.0f;
  float height = 1.0f;
  float up = 0.0f;
  float right = 0.0f;
};

ShaderHunter::RuntimeElementSignature BuildRuntimeElementSignature(const XFMemory& xf_memory,
                                                                   const BPMemory& bp_memory)
{
  ShaderHunter::RuntimeElementSignature signature;
  signature.valid = true;
  signature.perspective = xf_memory.projection.type == ProjectionType::Perspective;

  const float* projection = xf_memory.projection.rawProjection.data();
  if (signature.perspective)
  {
    const float hfov = 2.0f * std::atan(1.0f / projection[0]) * 180.0f / 3.14159265f;
    const float vfov = 2.0f * std::atan(1.0f / projection[2]) * 180.0f / 3.14159265f;
    const float far_plane = projection[5] / projection[4];
    const float near_plane = far_plane * projection[4] / (projection[4] - 1.0f);
    signature.perspective_hfov_x100 = static_cast<int>(std::lround(hfov * 100.0f));
    signature.perspective_vfov_x100 = static_cast<int>(std::lround(vfov * 100.0f));
    signature.perspective_near_x1000 = static_cast<int>(std::lround(near_plane * 1000.0f));
    signature.perspective_far_x100 = static_cast<int>(std::lround(far_plane * 100.0f));
  }
  else
  {
    const float left = -(projection[1] + 1.0f) / projection[0];
    const float right = left + 2.0f / projection[0];
    const float bottom = -(projection[3] + 1.0f) / projection[2];
    const float top = bottom + 2.0f / projection[2];
    signature.ortho_left_x100 = static_cast<int>(std::lround(left * 100.0f));
    signature.ortho_right_x100 = static_cast<int>(std::lround(right * 100.0f));
    signature.ortho_top_x100 = static_cast<int>(std::lround(top * 100.0f));
    signature.ortho_bottom_x100 = static_cast<int>(std::lround(bottom * 100.0f));
    // The per-draw ortho layer counter is gone (it only ever advanced under the removed Auto
    // Layer Spread option). Kept at 0 so existing INIs with sig_use_layer=1/sig_layer=0 —
    // i.e. every signature captured with the default settings — keep matching.
    signature.ortho_layer = 0;
  }

  const auto& viewport = xf_memory.viewport;
  signature.viewport_x = static_cast<int>(std::lround(viewport.xOrig));
  signature.viewport_y = static_cast<int>(std::lround(viewport.yOrig));
  signature.viewport_width = static_cast<int>(std::lround(std::abs(viewport.wd)));
  signature.viewport_height = static_cast<int>(std::lround(std::abs(viewport.ht)));
  signature.scissor_left = bp_memory.scissorTL.x;
  signature.scissor_top = bp_memory.scissorTL.y;
  signature.scissor_right = bp_memory.scissorBR.x;
  signature.scissor_bottom = bp_memory.scissorBR.y;
  signature.alpha_test_hex = bp_memory.alpha_test.hex;
  signature.ztest = bp_memory.zmode.test_enable != 0;
  signature.zupdate = bp_memory.zmode.update_enable != 0;
  signature.zfunc = static_cast<int>(bp_memory.zmode.func.Value());
  signature.blend_color_update = bp_memory.blendmode.color_update != 0;
  signature.blend_alpha_update = bp_memory.blendmode.alpha_update != 0;
  return signature;
}

MetroidProjectionMetrics BuildMetroidProjectionMetrics(const XFMemory& xf_memory,
                                                       u32 projection_sequence)
{
  MetroidProjectionMetrics metrics;
  metrics.projection_sequence = projection_sequence;
  metrics.perspective = xf_memory.projection.type == ProjectionType::Perspective;

  const float* projection = xf_memory.projection.rawProjection.data();
  if (metrics.perspective)
  {
    metrics.hfov = 2.0f * std::atan(1.0f / projection[0]) * 180.0f / 3.14159265f;
    metrics.vfov = 2.0f * std::atan(1.0f / projection[2]) * 180.0f / 3.14159265f;
    metrics.zfar = projection[5] / projection[4];
    metrics.znear = metrics.zfar * projection[4] / (projection[4] - 1.0f);
  }
  else
  {
    metrics.left = -(projection[1] + 1.0f) / projection[0];
    metrics.right = metrics.left + 2.0f / projection[0];
    metrics.bottom = -(projection[3] + 1.0f) / projection[2];
    metrics.top = metrics.bottom + 2.0f / projection[2];
    metrics.zfar = projection[5] / projection[4];
    metrics.znear = (1.0f + projection[4] * metrics.zfar) / projection[4];
  }

  return metrics;
}

MetroidElementProfile GetMetroidProfileForGameID(std::string_view game_id)
{
  if (game_id.starts_with("GM8") || game_id.starts_with("D43") || game_id.starts_with("D93"))
    return MetroidElementProfile::Prime1GC;
  if (game_id.starts_with("G2M") || game_id.starts_with("P2M"))
    return MetroidElementProfile::Prime2GC;
  if (game_id.starts_with("R3I"))
    return MetroidElementProfile::Prime1Wii;
  if (game_id.starts_with("R32"))
    return MetroidElementProfile::Prime2Wii;
  if (game_id.starts_with("RM3"))
    return MetroidElementProfile::Prime3;
  if (game_id.starts_with("R3M") || game_id.starts_with("R3O"))
    return MetroidElementProfile::TrilogyAuto;

  return MetroidElementProfile::None;
}

MetroidElementClassifier& GetMetroidElementClassifier()
{
  static MetroidElementClassifier classifier;
  return classifier;
}

constexpr int METROID_HUD_CONTEXT_DEFAULT = 0;
constexpr int METROID_HUD_CONTEXT_COMBAT = 1;
constexpr int METROID_HUD_CONTEXT_MENU = 2;

bool IsMetroidPrime2Profile(MetroidElementProfile profile)
{
  return profile == MetroidElementProfile::Prime2GC ||
         profile == MetroidElementProfile::Prime2Wii;
}

bool IsMetroidPrime1Profile(MetroidElementProfile profile)
{
  return profile == MetroidElementProfile::Prime1GC ||
         profile == MetroidElementProfile::Prime1Wii;
}

MetroidHydraHudSettings GetMetroidHydraHudSettings(MetroidElementProfile profile,
                                                   MetroidElementLayer layer,
                                                   std::string_view game_id)
{
  if (!IsMetroidPrime1Profile(profile))
    return {};

  if (!(game_id.starts_with("GM8") || game_id.starts_with("D93") || game_id.starts_with("R3I")))
    return {};

  switch (layer)
  {
  case MetroidElementLayer::HUD:
  case MetroidElementLayer::UnknownHUD:
  case MetroidElementLayer::MapOrHint:
  case MetroidElementLayer::Map:
    return {.enabled = true,
            .perspective_hud = true,
            .scale = 30.0f,
            .width = 0.79f,
            .height = 0.79f};

  case MetroidElementLayer::XRayHUD:
    // The classifier uses XRayHUD for the compact visor/reticle HUD projection in both X-Ray and
    // Thermal visor modes.  Those draws still contain 3D CMDL reticle pieces (beam/visor boxes),
    // so keep them on the Hydra perspective-HUD path instead of flattening them as a 2D overlay.
    return {.enabled = true,
            .perspective_hud = true,
            .scale = 30.0f,
            .width = 0.79f,
            .height = 0.79f};

  case MetroidElementLayer::DarkVisorHUD:
    return {.enabled = true,
            .perspective_hud = true,
            .scale = 5.0f,
            .width = 0.79f,
            .height = 0.79f};

  case MetroidElementLayer::VisorRadarHint:
    return {.enabled = true,
            .perspective_hud = true,
            .scale = 32.0f,
            .width = 0.79f,
            .height = 0.79f};

  case MetroidElementLayer::RadarDot:
    return {.enabled = true,
            .perspective_hud = true,
            .scale = 36.0f,
            .width = 0.79f,
            .height = 0.79f};

  case MetroidElementLayer::Visor:
    return {.enabled = true, .perspective_hud = true, .scale = 90.0f};

  case MetroidElementLayer::Helmet:
    return {.enabled = true,
            .perspective_hud = true,
            .scale = 100.0f,
            .width = 1.7f,
            .height = 1.7f};

  case MetroidElementLayer::ScanText:
    return {.enabled = true,
            .perspective_hud = true,
            .scale = 32.0f,
            .width = 0.8f,
            .height = 0.8f};

  case MetroidElementLayer::ScanHologram:
    return {.enabled = true,
            .perspective_hud = true,
            .scale = 40.0f,
            .width = 1.2f,
            .height = 1.2f};

  case MetroidElementLayer::ScanReticle:
    return {.enabled = true, .width = 1.0f, .height = 1.0f, .up = 0.14f, .right = 0.01f};

  default:
    return {};
  }
}

bool IsMetroidPerspectiveHudAnchorLayer(MetroidElementLayer layer)
{
  switch (layer)
  {
  case MetroidElementLayer::HUD:
  case MetroidElementLayer::UnknownHUD:
  case MetroidElementLayer::MapOrHint:
  case MetroidElementLayer::Map:
  case MetroidElementLayer::XRayHUD:
  case MetroidElementLayer::DarkVisorHUD:
  case MetroidElementLayer::Helmet:
    return true;

  default:
    return false;
  }
}

bool IsMetroidPrime1CombatContextLayer(MetroidElementLayer layer)
{
  switch (layer)
  {
  case MetroidElementLayer::Gun:
  case MetroidElementLayer::World:
  case MetroidElementLayer::Reticle:
  case MetroidElementLayer::WiiReticle:
  case MetroidElementLayer::XRayWorld:
  case MetroidElementLayer::ThermalGunAndDoor:
    return true;

  default:
    return false;
  }
}

bool IsMetroidPrime1MenuContextLayer(MetroidElementLayer layer)
{
  switch (layer)
  {
  case MetroidElementLayer::Map0:
  case MetroidElementLayer::Map1:
  case MetroidElementLayer::Map2:
  case MetroidElementLayer::Dialog:
  case MetroidElementLayer::MapMap:
  case MetroidElementLayer::MapLegend:
  case MetroidElementLayer::InventorySamus:
  case MetroidElementLayer::InventorySamusOutline:
  case MetroidElementLayer::MapNorth:
    return true;

  default:
    return false;
  }
}

bool IsMetroidPrime1CombatHudAnchorCandidate(MetroidElementLayer layer, float reference_view_z,
                                             int hud_context)
{
  // Normal combat visor draws its 3D HUD body as METROID_SCAN_TEXT instead of one of the
  // explicit HUD anchor layers. Use only the stable body-depth range as a combat-only fallback;
  // this excludes close reticle/minimap pieces (~-5.6), free-aim far draws (~-32), and menu/map
  // ScanText draws that should be anchored by their own UI context.
  return hud_context == METROID_HUD_CONTEXT_COMBAT && layer == MetroidElementLayer::ScanText &&
         std::isfinite(reference_view_z) && reference_view_z >= -22.0f &&
         reference_view_z <= -18.0f;
}

bool IsMetroidPrime1ScannerPreviewMask(const ShaderHunter::RuntimeElementSignature& signature)
{
  return signature.valid && !signature.perspective && signature.ortho_left_x100 == -32000 &&
         signature.ortho_right_x100 == 32000 && signature.ortho_top_x100 == 22400 &&
         signature.ortho_bottom_x100 == -22400 && signature.ortho_layer == 0 &&
         signature.viewport_x == 662 && signature.viewport_y == 566 &&
         signature.viewport_width == 320 && signature.viewport_height == 224 &&
         signature.scissor_left == 342 && signature.scissor_top == 342 &&
         signature.scissor_right == 981 && signature.scissor_bottom == 789 &&
         signature.alpha_test_hex == 0x007f0000 && signature.ztest && signature.zupdate &&
         signature.zfunc == 3 && signature.blend_color_update && signature.blend_alpha_update;
}

MetroidLayerBehavior GetMetroidLayerBehavior(MetroidElementLayer layer)
{
  switch (layer)
  {
  case MetroidElementLayer::EFBCopy:
  case MetroidElementLayer::BlackBars:
  case MetroidElementLayer::ScanVisor:
  case MetroidElementLayer::ScanDarken:
  case MetroidElementLayer::ScanHighlighter:
  case MetroidElementLayer::ScanBox:
  case MetroidElementLayer::ScanCircle:
  case MetroidElementLayer::ScanReticle:
    return {.skip = true};

  case MetroidElementLayer::Helmet:
  case MetroidElementLayer::HUD:
  case MetroidElementLayer::MorphballHUD:
  case MetroidElementLayer::XRayHUD:
  case MetroidElementLayer::DarkVisorHUD:
  case MetroidElementLayer::UnknownHUD:
  case MetroidElementLayer::VisorRadarHint:
  case MetroidElementLayer::RadarDot:
  case MetroidElementLayer::MorphballMapOrHint:
  case MetroidElementLayer::MapOrHint:
  case MetroidElementLayer::MorphballMap:
  case MetroidElementLayer::Map:
  case MetroidElementLayer::Map0:
  case MetroidElementLayer::Map1:
  case MetroidElementLayer::Map2:
  case MetroidElementLayer::Dialog:
  case MetroidElementLayer::MapMap:
  case MetroidElementLayer::MapLegend:
  case MetroidElementLayer::InventorySamus:
  case MetroidElementLayer::InventorySamusOutline:
  case MetroidElementLayer::MapNorth:
  case MetroidElementLayer::ScanText:
  case MetroidElementLayer::ScanHologram:
  case MetroidElementLayer::Visor:
  case MetroidElementLayer::VisorBootup:
  case MetroidElementLayer::UnknownVisor:
    return {.handling = ShaderHunter::HandlingType::HeadLocked};

  default:
    return {};
  }
}

// Row-major 3x3 helpers for the ControllerAnchor rotation path.
std::array<float, 9> Mul3x3(const std::array<float, 9>& a, const std::array<float, 9>& b)
{
  std::array<float, 9> m{};
  for (int r = 0; r < 3; ++r)
  {
    for (int c = 0; c < 3; ++c)
      m[r * 3 + c] = a[r * 3 + 0] * b[0 + c] + a[r * 3 + 1] * b[3 + c] + a[r * 3 + 2] * b[6 + c];
  }
  return m;
}

// Model-axis correction from the per-override Euler angles, applied in the controller's
// local frame: yaw about +Y, then pitch about +X, then roll about +Z. Models differ in
// which way they natively point (a blade along +Y, a barrel along -Z, ...); these dial
// the element onto the controller's aim direction.
std::array<float, 9> ControllerAnchorAxisCorrection(float yaw_deg, float pitch_deg,
                                                    float roll_deg)
{
  constexpr float DEG_TO_RAD = 0.01745329252f;
  const float cy = std::cos(yaw_deg * DEG_TO_RAD), sy = std::sin(yaw_deg * DEG_TO_RAD);
  const float cx = std::cos(pitch_deg * DEG_TO_RAD), sx = std::sin(pitch_deg * DEG_TO_RAD);
  const float cz = std::cos(roll_deg * DEG_TO_RAD), sz = std::sin(roll_deg * DEG_TO_RAD);
  const std::array<float, 9> rot_y = {cy, 0.0f, sy, 0.0f, 1.0f, 0.0f, -sy, 0.0f, cy};
  const std::array<float, 9> rot_x = {1.0f, 0.0f, 0.0f, 0.0f, cx, -sx, 0.0f, sx, cx};
  const std::array<float, 9> rot_z = {cz, -sz, 0.0f, sz, cz, 0.0f, 0.0f, 0.0f, 1.0f};
  return Mul3x3(Mul3x3(rot_y, rot_x), rot_z);
}
}  // namespace

// GX primitive -> RenderState primitive, no primitive restart
constexpr Common::EnumMap<PrimitiveType, Primitive::GX_DRAW_POINTS> primitive_from_gx{
    PrimitiveType::Triangles,  // GX_DRAW_QUADS
    PrimitiveType::Triangles,  // GX_DRAW_QUADS_2
    PrimitiveType::Triangles,  // GX_DRAW_TRIANGLES
    PrimitiveType::Triangles,  // GX_DRAW_TRIANGLE_STRIP
    PrimitiveType::Triangles,  // GX_DRAW_TRIANGLE_FAN
    PrimitiveType::Lines,      // GX_DRAW_LINES
    PrimitiveType::Lines,      // GX_DRAW_LINE_STRIP
    PrimitiveType::Points,     // GX_DRAW_POINTS
};

// GX primitive -> RenderState primitive, using primitive restart
constexpr Common::EnumMap<PrimitiveType, Primitive::GX_DRAW_POINTS> primitive_from_gx_pr{
    PrimitiveType::TriangleStrip,  // GX_DRAW_QUADS
    PrimitiveType::TriangleStrip,  // GX_DRAW_QUADS_2
    PrimitiveType::TriangleStrip,  // GX_DRAW_TRIANGLES
    PrimitiveType::TriangleStrip,  // GX_DRAW_TRIANGLE_STRIP
    PrimitiveType::TriangleStrip,  // GX_DRAW_TRIANGLE_FAN
    PrimitiveType::Lines,          // GX_DRAW_LINES
    PrimitiveType::Lines,          // GX_DRAW_LINE_STRIP
    PrimitiveType::Points,         // GX_DRAW_POINTS
};

// Due to the BT.601 standard which the GameCube is based on being a compromise
// between PAL and NTSC, neither standard gets square pixels. They are each off
// by ~9% in opposite directions.
// Just in case any game decides to take this into account, we do both these
// tests with a large amount of slop.

static float CalculateProjectionViewportRatio(const Projection::Raw& projection,
                                              const Viewport& viewport)
{
  const float projection_ar = projection[2] / projection[0];
  const float viewport_ar = viewport.wd / viewport.ht;

  return std::abs(projection_ar / viewport_ar);
}

static bool IsAnamorphicProjection(const Projection::Raw& projection, const Viewport& viewport,
                                   const VideoConfig& config)
{
  // If ratio between our projection and viewport aspect ratios is similar to 16:9 / 4:3
  // we have an anamorphic projection. This value can be overridden by a GameINI.
  // Game cheats that change the aspect ratio to natively unsupported ones
  // won't be automatically recognized here.

  return std::abs(CalculateProjectionViewportRatio(projection, viewport) -
                  config.widescreen_heuristic_widescreen_ratio) <
         config.widescreen_heuristic_aspect_ratio_slop;
}

static bool IsNormalProjection(const Projection::Raw& projection, const Viewport& viewport,
                               const VideoConfig& config)
{
  return std::abs(CalculateProjectionViewportRatio(projection, viewport) -
                  config.widescreen_heuristic_standard_ratio) <
         config.widescreen_heuristic_aspect_ratio_slop;
}

VertexManagerBase::VertexManagerBase()
    : m_cpu_vertex_buffer(MAXVBUFFERSIZE), m_cpu_index_buffer(MAXIBUFFERSIZE)
{
}

VertexManagerBase::~VertexManagerBase() = default;

MetroidElementProfile VertexManagerBase::GetCachedMetroidProfile()
{
  if (!m_metroid_profile_resolved)
  {
    std::string game_id = SConfig::GetInstance().GetGameID();
    if (game_id.empty())
      return MetroidElementProfile::None;  // ID not available yet; resolve on a later draw.
    m_metroid_profile = GetMetroidProfileForGameID(game_id);
    m_metroid_game_id = std::move(game_id);
    m_metroid_profile_resolved = true;
  }
  return m_metroid_profile;
}

bool VertexManagerBase::Initialize()
{
  auto& video_events = GetVideoEvents();

  m_frame_end_event =
      video_events.after_frame_event.Register([this](Core::System&) { OnEndFrame(); });
  m_after_present_event = video_events.after_present_event.Register(
      [this](const PresentInfo& pi) { m_ticks_elapsed = pi.emulated_timestamp; });
  m_index_generator.Init();
  m_custom_shader_cache = std::make_unique<CustomShaderCache>();
  m_cpu_cull.Init();
  return true;
}

u32 VertexManagerBase::GetRemainingSize() const
{
  return static_cast<u32>(m_end_buffer_pointer - m_cur_buffer_pointer);
}

void VertexManagerBase::AddIndices(OpcodeDecoder::Primitive primitive, u32 num_vertices)
{
  m_index_generator.AddIndices(primitive, num_vertices);
}

bool VertexManagerBase::AreAllVerticesCulled(VertexLoaderBase* loader,
                                             OpcodeDecoder::Primitive primitive, const u8* src,
                                             u32 count)
{
  return m_cpu_cull.AreAllVerticesCulled(loader, primitive, src, count);
}

DataReader VertexManagerBase::PrepareForAdditionalData(OpcodeDecoder::Primitive primitive,
                                                       u32 count, u32 stride, bool cullall)
{
  // Flush all EFB pokes. Since the buffer is shared, we can't draw pokes+primitives concurrently.
  g_framebuffer_manager->FlushEFBPokes();

  // The SSE vertex loader can write up to 4 bytes past the end
  u32 const needed_vertex_bytes = count * stride + 4;

  // We can't merge different kinds of primitives, so we have to flush here
  PrimitiveType new_primitive_type = g_backend_info.bSupportsPrimitiveRestart ?
                                         primitive_from_gx_pr[primitive] :
                                         primitive_from_gx[primitive];
  if (m_current_primitive_type != new_primitive_type) [[unlikely]]
  {
    Flush();

    // Have to update the rasterization state for point/line cull modes.
    m_current_primitive_type = new_primitive_type;
    SetRasterizationStateChanged();
  }

  u32 remaining_indices = GetRemainingIndices(primitive);
  u32 remaining_index_generator_indices = m_index_generator.GetRemainingIndices(primitive);

  // Check for size in buffer, if the buffer gets full, call Flush()
  if (!m_is_flushed && (count > remaining_index_generator_indices || count > remaining_indices ||
                        needed_vertex_bytes > GetRemainingSize())) [[unlikely]]
  {
    Flush();
  }

  m_cull_all = cullall;

  // need to alloc new buffer
  if (m_is_flushed) [[unlikely]]
  {
    if (cullall)
    {
      // This buffer isn't getting sent to the GPU. Just allocate it on the cpu.
      m_cur_buffer_pointer = m_base_buffer_pointer = m_cpu_vertex_buffer.data();
      m_end_buffer_pointer = m_base_buffer_pointer + m_cpu_vertex_buffer.size();
      m_index_generator.Start(m_cpu_index_buffer.data());
    }
    else
    {
      ResetBuffer(stride);
    }

    remaining_index_generator_indices = m_index_generator.GetRemainingIndices(primitive);
    remaining_indices = GetRemainingIndices(primitive);
    m_is_flushed = false;
  }

  // Now that we've reset the buffer, there should be enough space. It's possible that we still
  // won't have enough space in a few rare cases, such as vertex shader line/point expansion with a
  // ton of lines in one draw command, in which case we will either need to add support for
  // splitting a single draw command into multiple draws or using bigger indices.
  ASSERT_MSG(VIDEO, count <= remaining_index_generator_indices,
             "VertexManager: Too few remaining index values ({} > {}). "
             "32-bit indices or primitive breaking needed.",
             count, remaining_index_generator_indices);
  ASSERT_MSG(VIDEO, count <= remaining_indices,
             "VertexManager: Buffer not large enough for all indices! ({} > {}) "
             "Increase MAXIBUFFERSIZE or we need primitive breaking after all.",
             count, remaining_indices);
  ASSERT_MSG(VIDEO, needed_vertex_bytes <= GetRemainingSize(),
             "VertexManager: Buffer not large enough for all vertices! ({} > {}) "
             "Increase MAXVBUFFERSIZE or we need primitive breaking after all.",
             needed_vertex_bytes, GetRemainingSize());

  return DataReader(m_cur_buffer_pointer, m_end_buffer_pointer);
}

DataReader VertexManagerBase::DisableCullAll(u32 stride)
{
  if (m_cull_all)
  {
    m_cull_all = false;
    ResetBuffer(stride);
  }
  return DataReader(m_cur_buffer_pointer, m_end_buffer_pointer);
}

void VertexManagerBase::FlushData(u32 count, u32 stride)
{
  m_cur_buffer_pointer += count * stride;
}

u32 VertexManagerBase::GetRemainingIndices(OpcodeDecoder::Primitive primitive) const
{
  const u32 index_len = MAXIBUFFERSIZE - m_index_generator.GetIndexLen();

  if (primitive >= Primitive::GX_DRAW_LINES)
  {
    if (g_Config.UseVSForLinePointExpand())
    {
      if (g_backend_info.bSupportsPrimitiveRestart)
      {
        switch (primitive)
        {
        case Primitive::GX_DRAW_LINES:
          return index_len / 5 * 2;
        case Primitive::GX_DRAW_LINE_STRIP:
          return index_len / 5 + 1;
        case Primitive::GX_DRAW_POINTS:
          return index_len / 5;
        default:
          return 0;
        }
      }
      else
      {
        switch (primitive)
        {
        case Primitive::GX_DRAW_LINES:
          return index_len / 6 * 2;
        case Primitive::GX_DRAW_LINE_STRIP:
          return index_len / 6 + 1;
        case Primitive::GX_DRAW_POINTS:
          return index_len / 6;
        default:
          return 0;
        }
      }
    }
    else
    {
      switch (primitive)
      {
      case Primitive::GX_DRAW_LINES:
        return index_len;
      case Primitive::GX_DRAW_LINE_STRIP:
        return index_len / 2 + 1;
      case Primitive::GX_DRAW_POINTS:
        return index_len;
      default:
        return 0;
      }
    }
  }
  else if (g_backend_info.bSupportsPrimitiveRestart)
  {
    switch (primitive)
    {
    case Primitive::GX_DRAW_QUADS:
    case Primitive::GX_DRAW_QUADS_2:
      return index_len / 5 * 4;
    case Primitive::GX_DRAW_TRIANGLES:
      return index_len / 4 * 3;
    case Primitive::GX_DRAW_TRIANGLE_STRIP:
      return index_len / 1 - 1;
    case Primitive::GX_DRAW_TRIANGLE_FAN:
      return index_len / 6 * 4 + 1;
    default:
      return 0;
    }
  }
  else
  {
    switch (primitive)
    {
    case Primitive::GX_DRAW_QUADS:
    case Primitive::GX_DRAW_QUADS_2:
      return index_len / 6 * 4;
    case Primitive::GX_DRAW_TRIANGLES:
      return index_len;
    case Primitive::GX_DRAW_TRIANGLE_STRIP:
      return index_len / 3 + 2;
    case Primitive::GX_DRAW_TRIANGLE_FAN:
      return index_len / 3 + 2;
    default:
      return 0;
    }
  }
}

auto VertexManagerBase::ResetFlushAspectRatioCount() -> FlushStatistics
{
  const auto result = m_flush_statistics;
  m_flush_statistics = {};
  return result;
}

void VertexManagerBase::ResetBuffer(u32 vertex_stride)
{
  m_base_buffer_pointer = m_cpu_vertex_buffer.data();
  m_cur_buffer_pointer = m_cpu_vertex_buffer.data();
  m_end_buffer_pointer = m_base_buffer_pointer + m_cpu_vertex_buffer.size();
  m_index_generator.Start(m_cpu_index_buffer.data());
}

void VertexManagerBase::CommitBuffer(u32 num_vertices, u32 vertex_stride, u32 num_indices,
                                     u32* out_base_vertex, u32* out_base_index)
{
  *out_base_vertex = 0;
  *out_base_index = 0;
}

void VertexManagerBase::DrawCurrentBatch(u32 base_index, u32 num_indices, u32 base_vertex)
{
  // If bounding box is enabled, we need to flush any changes first, then invalidate what we have.
  if (g_bounding_box->IsEnabled() && g_ActiveConfig.bBBoxEnable && g_backend_info.bSupportsBBox)
  {
    g_bounding_box->Flush();
  }

  g_gfx->DrawIndexed(base_index, num_indices, base_vertex);
}

void VertexManagerBase::UploadUniforms()
{
}

void VertexManagerBase::InvalidateConstants()
{
  auto& system = Core::System::GetInstance();
  auto& vertex_shader_manager = system.GetVertexShaderManager();
  auto& geometry_shader_manager = system.GetGeometryShaderManager();
  auto& pixel_shader_manager = system.GetPixelShaderManager();
  vertex_shader_manager.dirty = true;
  geometry_shader_manager.dirty = true;
  pixel_shader_manager.dirty = true;
}

void VertexManagerBase::UploadUtilityUniforms(const void* uniforms, u32 uniforms_size)
{
}

void VertexManagerBase::UploadUtilityVertices(const void* vertices, u32 vertex_stride,
                                              u32 num_vertices, const u16* indices, u32 num_indices,
                                              u32* out_base_vertex, u32* out_base_index)
{
  // The GX vertex list should be flushed before any utility draws occur.
  ASSERT(m_is_flushed);

  // Copy into the buffers usually used for GX drawing.
  ResetBuffer(std::max(vertex_stride, 1u));
  if (vertices)
  {
    const u32 copy_size = vertex_stride * num_vertices;
    ASSERT((m_cur_buffer_pointer + copy_size) <= m_end_buffer_pointer);
    std::memcpy(m_cur_buffer_pointer, vertices, copy_size);
    m_cur_buffer_pointer += copy_size;
  }
  if (indices)
    m_index_generator.AddExternalIndices(indices, num_indices, num_vertices);

  CommitBuffer(num_vertices, vertex_stride, num_indices, out_base_vertex, out_base_index);
}

u32 VertexManagerBase::GetTexelBufferElementSize(TexelBufferFormat buffer_format)
{
  // R8 - 1, R16 - 2, RGBA8 - 4, R32G32 - 8
  return 1u << static_cast<u32>(buffer_format);
}

bool VertexManagerBase::UploadTexelBuffer(const void* data, u32 data_size, TexelBufferFormat format,
                                          u32* out_offset)
{
  return false;
}

bool VertexManagerBase::UploadTexelBuffer(const void* data, u32 data_size, TexelBufferFormat format,
                                          u32* out_offset, const void* palette_data,
                                          u32 palette_size, TexelBufferFormat palette_format,
                                          u32* palette_offset)
{
  return false;
}

BitSet32 VertexManagerBase::UsedTextures() const
{
  BitSet32 usedtextures;
  for (u32 i = 0; i < bpmem.genMode.numtevstages + 1u; ++i)
    if (bpmem.tevorders[i / 2].getEnable(i & 1))
      usedtextures[bpmem.tevorders[i / 2].getTexMap(i & 1)] = true;

  if (bpmem.genMode.numindstages > 0)
    for (unsigned int i = 0; i < bpmem.genMode.numtevstages + 1u; ++i)
      if (bpmem.tevind[i].IsActive() && bpmem.tevind[i].bt < bpmem.genMode.numindstages)
        usedtextures[bpmem.tevindref.getTexMap(bpmem.tevind[i].bt)] = true;

  return usedtextures;
}

void VertexManagerBase::Flush()
{
  if (m_is_flushed)
    return;

  m_is_flushed = true;

  if (m_draw_counter == 0)
  {
    // This is more or less the start of the Frame
    GetVideoEvents().before_frame_event.Trigger();
  }

  if (xfmem.numTexGen.numTexGens != bpmem.genMode.numtexgens ||
      xfmem.numChan.numColorChans != bpmem.genMode.numcolchans)
  {
    ERROR_LOG_FMT(
        VIDEO,
        "Mismatched configuration between XF and BP stages - {}/{} texgens, {}/{} colors. "
        "Skipping draw. Please report on the issue tracker.",
        xfmem.numTexGen.numTexGens, bpmem.genMode.numtexgens.Value(), xfmem.numChan.numColorChans,
        bpmem.genMode.numcolchans.Value());

    // Analytics reporting so we can discover which games have this problem, that way when we
    // eventually simulate the behavior we have test cases for it.
    if (xfmem.numTexGen.numTexGens != bpmem.genMode.numtexgens)
    {
      DolphinAnalytics::Instance().ReportGameQuirk(GameQuirk::MismatchedGPUTexGensBetweenXFAndBP);
    }
    if (xfmem.numChan.numColorChans != bpmem.genMode.numcolchans)
    {
      DolphinAnalytics::Instance().ReportGameQuirk(GameQuirk::MismatchedGPUColorsBetweenXFAndBP);
    }

    HideObjectEngine::Engine::GetInstance().DiscardPendingCapturedPrefixes();
    return;
  }

#if defined(_DEBUG) || defined(DEBUGFAST)
  PRIM_LOG("frame{}:\n texgen={}, numchan={}, dualtex={}, ztex={}, cole={}, alpe={}, ze={}",
           g_ActiveConfig.iSaveTargetId, xfmem.numTexGen.numTexGens, xfmem.numChan.numColorChans,
           xfmem.dualTexTrans.enabled, bpmem.ztex2.op.Value(), bpmem.blendmode.color_update.Value(),
           bpmem.blendmode.alpha_update.Value(), bpmem.zmode.update_enable.Value());

  for (u32 i = 0; i < xfmem.numChan.numColorChans; ++i)
  {
    LitChannel* ch = &xfmem.color[i];
    PRIM_LOG("colchan{}: matsrc={}, light={:#x}, ambsrc={}, diffunc={}, attfunc={}", i,
             ch->matsource.Value(), ch->GetFullLightMask(), ch->ambsource.Value(),
             ch->diffusefunc.Value(), ch->attnfunc.Value());
    ch = &xfmem.alpha[i];
    PRIM_LOG("alpchan{}: matsrc={}, light={:#x}, ambsrc={}, diffunc={}, attfunc={}", i,
             ch->matsource.Value(), ch->GetFullLightMask(), ch->ambsource.Value(),
             ch->diffusefunc.Value(), ch->attnfunc.Value());
  }

  for (u32 i = 0; i < xfmem.numTexGen.numTexGens; ++i)
  {
    TexMtxInfo tinfo = xfmem.texMtxInfo[i];
    if (tinfo.texgentype != TexGenType::EmbossMap)
      tinfo.hex &= 0x7ff;
    if (tinfo.texgentype != TexGenType::Regular)
      tinfo.projection = TexSize::ST;

    PRIM_LOG("txgen{}: proj={}, input={}, gentype={}, srcrow={}, embsrc={}, emblght={}, "
             "postmtx={}, postnorm={}",
             i, tinfo.projection.Value(), tinfo.inputform.Value(), tinfo.texgentype.Value(),
             tinfo.sourcerow.Value(), tinfo.embosssourceshift.Value(),
             tinfo.embosslightshift.Value(), xfmem.postMtxInfo[i].index.Value(),
             xfmem.postMtxInfo[i].normalize.Value());
  }

  PRIM_LOG("pixel: tev={}, ind={}, texgen={}, dstalpha={}, alphatest={:#x}",
           bpmem.genMode.numtevstages.Value() + 1, bpmem.genMode.numindstages.Value(),
           bpmem.genMode.numtexgens.Value(), bpmem.dstalpha.enable.Value(),
           (bpmem.alpha_test.hex >> 16) & 0xff);
#endif

  // Track some stats used elsewhere by the anamorphic widescreen heuristic.
  auto& system = Core::System::GetInstance();
  if (!system.IsWii())
  {
    const bool is_perspective = xfmem.projection.type == ProjectionType::Perspective;

    auto& counts =
        is_perspective ? m_flush_statistics.perspective : m_flush_statistics.orthographic;

    const auto& projection = xfmem.projection.rawProjection;
    // TODO: Potentially the viewport size could be used as weight for the flush count average.
    // This way a small minimap would have less effect than a fullscreen projection.
    const auto& viewport = xfmem.viewport;

    // FYI: This average is based on flushes.
    // It doesn't look at vertex counts like the heuristic does.
    counts.average_ratio.Push(CalculateProjectionViewportRatio(projection, viewport));

    if (IsAnamorphicProjection(projection, viewport, g_ActiveConfig))
    {
      ++counts.anamorphic_flush_count;
      counts.anamorphic_vertex_count += m_index_generator.GetIndexLen();
    }
    else if (IsNormalProjection(projection, viewport, g_ActiveConfig))
    {
      ++counts.normal_flush_count;
      counts.normal_vertex_count += m_index_generator.GetIndexLen();
    }
    else
    {
      ++counts.other_flush_count;
      counts.other_vertex_count += m_index_generator.GetIndexLen();
    }
  }

  auto& pixel_shader_manager = system.GetPixelShaderManager();
  auto& geometry_shader_manager = system.GetGeometryShaderManager();
  auto& vertex_shader_manager = system.GetVertexShaderManager();
  auto& xf_state_manager = system.GetXFStateManager();
  bool committed_hide_object_capture = false;

  // VR passthrough: coverage defaults to fully opaque each draw; a matching
  // Passthrough override below replaces it with the element's opacity for this draw.
  pixel_shader_manager.SetVRPassthroughAlpha(1.0f);

  if (g_ActiveConfig.bGraphicMods)
  {
    const double seconds_elapsed =
        static_cast<double>(m_ticks_elapsed) / system.GetSystemTimers().GetTicksPerSecond();
    pixel_shader_manager.constants.time_ms = seconds_elapsed * 1000;
  }

  CalculateNormals(VertexLoaderManager::GetCurrentVertexFormat());
  // Calculate ZSlope for zfreeze
  const auto used_textures = UsedTextures();
  std::vector<std::string> texture_names;
  Common::SmallVector<u32, 8> texture_units;
  std::array<SamplerState, 8> samplers;
  if (!m_cull_all)
  {
    if (!g_ActiveConfig.bGraphicMods)
    {
      for (const u32 i : used_textures)
      {
        const auto cache_entry = g_texture_cache->Load(i);
        if (!cache_entry)
          continue;
        const float custom_tex_scale = cache_entry->GetWidth() / float(cache_entry->native_width);
        samplers[i] = TextureCacheBase::GetSamplerState(
            i, custom_tex_scale, cache_entry->is_custom_tex, cache_entry->has_arbitrary_mips);
      }
    }
    else
    {
      for (const u32 i : used_textures)
      {
        const auto cache_entry = g_texture_cache->Load(i);
        if (cache_entry)
        {
          if (!Common::Contains(texture_names, cache_entry->texture_info_name))
          {
            texture_names.push_back(cache_entry->texture_info_name);
            texture_units.push_back(i);
          }

          const float custom_tex_scale = cache_entry->GetWidth() / float(cache_entry->native_width);
          samplers[i] = TextureCacheBase::GetSamplerState(
              i, custom_tex_scale, cache_entry->is_custom_tex, cache_entry->has_arbitrary_mips);
        }
      }
    }
  }
  vertex_shader_manager.SetConstants(texture_names, xf_state_manager);
  if (!bpmem.genMode.zfreeze)
  {
    // Must be done after VertexShaderManager::SetConstants()
    CalculateZSlope(VertexLoaderManager::GetCurrentVertexFormat());
  }
  else if (m_zslope.dirty && !m_cull_all)  // or apply any dirty ZSlopes
  {
    pixel_shader_manager.SetZSlope(m_zslope.dfdx, m_zslope.dfdy, m_zslope.f0);
    m_zslope.dirty = false;
  }

  if (!m_cull_all)
  {
    CustomPixelShaderContents custom_pixel_shader_contents;
    std::optional<CustomPixelShader> custom_pixel_shader;
    std::vector<std::string> custom_pixel_texture_names;
    std::span<u8> custom_pixel_shader_uniforms;
    bool skip = false;
    for (size_t i = 0; i < texture_names.size(); i++)
    {
      GraphicsModActionData::DrawStarted draw_started{texture_units, &skip, &custom_pixel_shader,
                                                      &custom_pixel_shader_uniforms};
      for (const auto& action : g_graphics_mod_manager->GetDrawStartedActions(texture_names[i]))
      {
        action->OnDrawStarted(&draw_started);
        if (custom_pixel_shader)
        {
          custom_pixel_shader_contents.shaders.push_back(*custom_pixel_shader);
          custom_pixel_texture_names.push_back(texture_names[i]);
        }
        custom_pixel_shader = std::nullopt;
      }
    }

    // Now the vertices can be flushed to the GPU. Everything following the CommitBuffer() call
    // must be careful to not upload any utility vertices, as the binding will be lost otherwise.
    const u32 num_indices = m_index_generator.GetIndexLen();
    if (num_indices == 0)
    {
      HideObjectEngine::Engine::GetInstance().DiscardPendingCapturedPrefixes();
      return;
    }

    // Texture loading can cause palettes to be applied (-> uniforms -> draws).
    // Palette application does not use vertices, only a full-screen quad, so this is okay.
    // Same with GPU texture decoding, which uses compute shaders.
    g_texture_cache->BindTextures(used_textures, samplers);

    if (!skip)
    {
      UpdatePipelineConfig();
      UpdatePipelineObject();
      bool shader_hunter_force_pink = false;
      if (m_current_pipeline_object)
      {
        // Shader Hunter: register shader hashes and check for skip.
        // Also check persistent overrides (always active, even when hunting is disabled).
        bool hunter_skip = false;
        bool elements_skip = false;
        bool texmgr_skip = false;
        auto& hunter = ShaderHunter::GetInstance();
        auto& elements = ElementsGroupManager::GetInstance();
        auto& texmgr = TextureElementManager::GetInstance();
        const bool hunter_enabled = hunter.IsEnabled();
        const bool hunter_debug_logging = hunter.IsDebugLogging();
        const bool hunter_has_overrides = hunter.HasOverrides();
        const bool elements_popup_open = elements.IsPopupOpen();
        const bool elements_has_overrides = elements.HasOverrides();
        const bool metroid_profile_active =
            GetCachedMetroidProfile() != MetroidElementProfile::None;
        const bool elements_runtime_active =
            elements_popup_open || elements_has_overrides || metroid_profile_active;
        const bool hunter_needs_families = hunter.NeedsShaderFamilySignatures();
        const bool hunter_needs_textures = hunter.NeedsTextureHashes();
        const bool texmgr_has_overrides = texmgr.HasOverrides();
        const bool texmgr_hunter_active = texmgr.IsHunterActive();
        const bool texmgr_active = texmgr_has_overrides || texmgr_hunter_active;
        // In flat 2D "cinema" mode the game renders mono exactly like a normal flat game. The
        // Shader/Elements/Textures overrides (and the hunter) only skip or reproject draws for
        // stereo VR, so running them here would corrupt the flat image and waste work — skip the
        // whole override/hunter pass when the panel path is active.
        const bool vr_flat_mode = g_ActiveConfig.vr_flat_screen;
        if (!vr_flat_mode && (hunter_enabled || hunter_has_overrides || hunter_debug_logging ||
                              elements_runtime_active || texmgr_active))
        {
          const auto& vs = m_current_pipeline_config.vs_uid;
          const auto& ps = m_current_pipeline_config.ps_uid;
          const auto& gs = m_current_pipeline_config.gs_uid;
          const u64 vs_hash =
              Common::ComputeCRC32(vs.GetUidDataRaw(), static_cast<u32>(vs.GetUidDataSize()));
          const u64 ps_hash =
              Common::ComputeCRC32(ps.GetUidDataRaw(), static_cast<u32>(ps.GetUidDataSize()));
          const u64 gs_hash =
              Common::ComputeCRC32(gs.GetUidDataRaw(), static_cast<u32>(gs.GetUidDataSize()));

          std::array<u64, 8> tex_hashes{};
          std::array<std::string, 8> tex_names{};
          const bool needs_texture_hashes =
              hunter_enabled || hunter_needs_textures || elements_runtime_active || texmgr_active;
          const bool needs_texture_names =
              hunter_enabled || elements_popup_open || texmgr_hunter_active;
          if (needs_texture_hashes || needs_texture_names)
          {
            for (u32 i = 0; i < 8; i++)
            {
              if (needs_texture_hashes)
                tex_hashes[i] = g_texture_cache->GetBoundTextureHash(i);
              if (needs_texture_names)
                tex_names[i] = g_texture_cache->GetBoundTextureName(i);
            }
          }

          if (hunter_enabled || hunter_needs_textures)
            hunter.SetCurrentDrawTextures(tex_hashes, tex_names);

          if (texmgr_hunter_active)
            texmgr.CaptureDrawTextures(tex_hashes, tex_names);

          u64 vs_family = 0;
          u64 ps_family = 0;
          u64 gs_family = 0;
          if (hunter_enabled || hunter_needs_families || elements_runtime_active)
          {
            vs_family = hunter.RegisterShader(ShaderHunter::ShaderType::Vertex, vs_hash,
                                              vs.GetUidDataRaw(), vs.GetUidDataSize());
            ps_family = hunter.RegisterShader(ShaderHunter::ShaderType::Pixel, ps_hash,
                                              ps.GetUidDataRaw(), ps.GetUidDataSize());
            gs_family = hunter.RegisterShader(ShaderHunter::ShaderType::Geometry, gs_hash,
                                              gs.GetUidDataRaw(), gs.GetUidDataSize());
            hunter.SetCurrentDrawShaderFamilies(vs_family, ps_family, gs_family);
          }

          ShaderHunter::RuntimeElementSignature draw_signature{};
          if (hunter_enabled || elements_runtime_active)
          {
            draw_signature = BuildRuntimeElementSignature(xfmem, bpmem);
            if (hunter_enabled)
              hunter.SetCurrentDrawSignature(draw_signature);
          }

          if (hunter_enabled)
          {
            hunter.RegisterDrawCombination(vs_hash, ps_hash, gs_hash);
            hunter_skip = hunter.ShouldSkipDraw(vs_hash, ps_hash, gs_hash);
            shader_hunter_force_pink = hunter.ShouldHighlightSelectedDraw();
          }

          std::optional<ElementsGroupManager::DrawRecord> element_draw;
          MetroidElementLayer metroid_layer = MetroidElementLayer::Unknown;
          MetroidElementProfile metroid_profile = MetroidElementProfile::None;
          MetroidProjectionMetrics metroid_metrics{};
          bool uses_mp2_dark_copy = false;
          bool uses_mp2_dark_highlight_copy = false;
          if (elements_runtime_active)
          {
            element_draw.emplace(ElementsGroupManager::DrawRecord{
                .draw_index = -1,
                .draw_sequence = m_draw_counter + 1,
                .vs_hash = vs_hash,
                .ps_hash = ps_hash,
                .gs_hash = gs_hash,
                .vs_family = vs_family,
                .ps_family = ps_family,
                .gs_family = gs_family,
                .signature = draw_signature,
                .textures = tex_hashes,
                .texture_names = tex_names});

            if (metroid_profile_active)
            {
              metroid_profile = GetCachedMetroidProfile();
              metroid_metrics = BuildMetroidProjectionMetrics(xfmem, m_draw_counter);
              metroid_layer =
                  GetMetroidElementClassifier().Classify(metroid_profile, metroid_metrics);
              if (IsMetroidPrime1Profile(metroid_profile) &&
                  IsMetroidPrime1ScannerPreviewMask(draw_signature))
              {
                metroid_layer = MetroidElementLayer::ScanDarken;
              }
              element_draw->profile_id = metroid_profile;
              element_draw->profile_layer = metroid_layer;
              element_draw->profile_layer_name =
                  std::string(MetroidElementLayerToDisplayName(metroid_layer));

              if (IsMetroidPrime1Profile(metroid_profile))
              {
                if (IsMetroidPrime1MenuContextLayer(metroid_layer))
                {
                  m_metroid_prime1_menu_context_seen = true;
                  m_metroid_prime1_combat_context_seen = false;
                }
                else if (!m_metroid_prime1_menu_context_seen &&
                         IsMetroidPrime1CombatContextLayer(metroid_layer))
                {
                  m_metroid_prime1_combat_context_seen = true;
                }
              }

              // Trilogy resolves to TrilogyAuto (never a Prime2 profile), but its MP2 content
              // still copies the 408x286 dark-visor highlight source. That shape is
              // MP2-specific, so scan for it under TrilogyAuto too. The 640x448 full-view dark
              // copy stays Prime2-profile-only — under Trilogy that shape collides with MP1
              // thermal sources.
              const bool trilogy_auto_profile =
                  metroid_profile == MetroidElementProfile::TrilogyAuto;
              if (IsMetroidPrime2Profile(metroid_profile) || trilogy_auto_profile)
              {
                for (const u32 i : used_textures)
                {
                  if (!trilogy_auto_profile &&
                      g_texture_cache->IsBoundMetroidPrime2DarkTexture(i))
                    uses_mp2_dark_copy = true;
                  if (g_texture_cache->IsBoundMetroidPrime2DarkHighlightTexture(i))
                    uses_mp2_dark_highlight_copy = true;
                  if (uses_mp2_dark_copy && uses_mp2_dark_highlight_copy)
                    break;
                }
              }
            }

            HideObjectEngine::Engine::GetInstance().CommitCapturedPrefixesForDraw(
                element_draw->draw_sequence);
            committed_hide_object_capture = true;

            const auto preview_action = elements.RegisterDraw(*element_draw);
            elements_skip = preview_action == ElementsGroupManager::PreviewAction::Skip;
            if (preview_action == ElementsGroupManager::PreviewAction::Pink)
              shader_hunter_force_pink = true;
          }

          // Register flag shaders (must be before skip/handling checks)
          if (hunter_has_overrides)
            hunter.RegisterFlags(vs_hash, ps_hash, gs_hash);
          if (elements_runtime_active)
            elements.RegisterFlagsForDraw(*element_draw);

          if (!hunter_skip && !elements_skip && elements_has_overrides)
            elements_skip = elements.ShouldSkipByOverride(*element_draw);

          if (!hunter_skip && !elements_skip && metroid_profile_active)
            elements_skip = GetMetroidLayerBehavior(metroid_layer).skip;

          if (!hunter_skip && !elements_skip && hunter_has_overrides)
            hunter_skip = hunter.ShouldSkipByOverride(vs_hash, ps_hash, gs_hash);

          // Texture Element Override skip: match purely on bound texture hash (fallback).
          if (!hunter_skip && !elements_skip && texmgr_has_overrides)
            texmgr_skip = texmgr.ShouldSkipByTexture(tex_hashes);

          // Live preview while the Texture Hunter browser is open: skip or pink-highlight draws
          // binding a checked texture (Skip/Pink chosen in the browser's Preview mode toggle).
          if (texmgr_hunter_active && texmgr.HasPreviewMatch(tex_hashes))
          {
            if (texmgr.IsPreviewPink())
              shader_hunter_force_pink = true;
            else
              texmgr_skip = true;
          }

          // Check for screen/fullscreen handling overrides (VR stereo mode override)
          if (!hunter_skip && !elements_skip && !texmgr_skip)
          {
            auto handling = ShaderHunter::HandlingType::Skip;
            float element_depth = -1.0f;
            float units_per_meter = -1.0f;
            float passthrough_opacity = 0.0f;
            ElementsGroupManager::CameraAnchorParams anchor_params;
            ElementsGroupManager::ControllerAnchorParams controller_anchor_params;
            const MetroidHydraHudSettings metroid_hydra_hud =
                metroid_profile_active ?
                    GetMetroidHydraHudSettings(metroid_profile, metroid_layer, m_metroid_game_id) :
                    MetroidHydraHudSettings{};

            if (elements_has_overrides)
              handling = elements.GetOverrideHandling(*element_draw);
            if (handling != ShaderHunter::HandlingType::Skip)
            {
              if (handling == ShaderHunter::HandlingType::Screen ||
                  handling == ShaderHunter::HandlingType::HeadLocked)
              {
                element_depth = elements.GetOverrideElementDepth(*element_draw);
              }
              else if (handling == ShaderHunter::HandlingType::UnitsPerMeter)
              {
                units_per_meter = elements.GetOverrideUnitsPerMeter(*element_draw);
              }
              else if (handling == ShaderHunter::HandlingType::Passthrough)
              {
                passthrough_opacity = elements.GetOverridePassthroughOpacity(*element_draw);
              }
              else if (handling == ShaderHunter::HandlingType::CameraAnchor)
              {
                elements.GetOverrideCameraAnchor(*element_draw, &anchor_params);
              }
              else if (handling == ShaderHunter::HandlingType::ControllerAnchor)
              {
                elements.GetOverrideControllerAnchor(*element_draw, &controller_anchor_params);
              }
            }
            else if (hunter_has_overrides)
            {
              handling = hunter.GetOverrideHandling(vs_hash, ps_hash, gs_hash);
              if (handling == ShaderHunter::HandlingType::Screen ||
                  handling == ShaderHunter::HandlingType::HeadLocked)
              {
                element_depth = hunter.GetOverrideElementDepth(vs_hash, ps_hash, gs_hash);
              }
              else if (handling == ShaderHunter::HandlingType::UnitsPerMeter)
              {
                units_per_meter = hunter.GetOverrideUnitsPerMeter(vs_hash, ps_hash, gs_hash);
              }
              else if (handling == ShaderHunter::HandlingType::Passthrough)
              {
                passthrough_opacity =
                    hunter.GetOverridePassthroughOpacity(vs_hash, ps_hash, gs_hash);
              }
              else if (handling == ShaderHunter::HandlingType::CameraAnchor)
              {
                hunter.GetOverrideCameraAnchor(vs_hash, ps_hash, gs_hash, &anchor_params);
              }
              else if (handling == ShaderHunter::HandlingType::ControllerAnchor)
              {
                hunter.GetOverrideControllerAnchor(vs_hash, ps_hash, gs_hash,
                                                   &controller_anchor_params);
              }
            }
            // Texture Element Override (fallback): match purely on bound texture hash, applied
            // only when neither Elements nor Shader overrides produced a handling for this draw.
            if (handling == ShaderHunter::HandlingType::Skip && texmgr_has_overrides)
            {
              handling = texmgr.GetHandlingForTextures(tex_hashes, &element_depth,
                                                       &units_per_meter, &passthrough_opacity,
                                                       &anchor_params, &controller_anchor_params);
            }
            if (handling == ShaderHunter::HandlingType::Skip && metroid_profile_active)
              handling = GetMetroidLayerBehavior(metroid_layer).handling;
            if (handling == ShaderHunter::HandlingType::Skip && uses_mp2_dark_copy)
            {
              handling = ShaderHunter::HandlingType::Fullscreen;
            }
            if (handling == ShaderHunter::HandlingType::Skip && uses_mp2_dark_highlight_copy &&
                !metroid_metrics.perspective)
            {
              handling = ShaderHunter::HandlingType::Fullscreen;
            }

            if (handling == ShaderHunter::HandlingType::Screen)
            {
              geometry_shader_manager.vr_stereo_override = -1.0f;
              if (element_depth >= 0.0f)
                geometry_shader_manager.vr_element_depth_override = element_depth;
            }
            else if (handling == ShaderHunter::HandlingType::Fullscreen)
            {
              geometry_shader_manager.vr_stereo_override = 0.0f;
            }
            else if (handling == ShaderHunter::HandlingType::FullscreenMono)
            {
              geometry_shader_manager.vr_stereo_override = 0.0f;
            }
            else if (handling == ShaderHunter::HandlingType::HeadLocked)
            {
              const bool perspective_metroid_hud =
                  metroid_hydra_hud.perspective_hud && metroid_metrics.perspective;
              geometry_shader_manager.vr_stereo_override = perspective_metroid_hud ? -3.0f : -2.0f;
              if (metroid_hydra_hud.enabled)
              {
                const auto& pnm = vertex_shader_manager.constants.posnormalmatrix;
                const float metroid_hud_ref_z = pnm[2][3];
                int metroid_hud_context = METROID_HUD_CONTEXT_DEFAULT;
                if (IsMetroidPrime1Profile(metroid_profile))
                {
                  if (m_metroid_prime1_menu_context_seen)
                    metroid_hud_context = METROID_HUD_CONTEXT_MENU;
                  else if (m_metroid_prime1_combat_context_seen)
                    metroid_hud_context = METROID_HUD_CONTEXT_COMBAT;
                }
                // Radar/minimap layers self-centre on their own origin depth in the -3 path
                // (consumed and reset by GeometryShaderManager::SetConstants).
                const std::string_view layer_name = MetroidElementLayerToININame(metroid_layer);
                geometry_shader_manager.vr_metroid_hud_self_center =
                    layer_name.find("RADAR") != std::string_view::npos;
                geometry_shader_manager.vr_metroid_hud_anchor_candidate =
                    perspective_metroid_hud &&
                    (IsMetroidPerspectiveHudAnchorLayer(metroid_layer) ||
                     IsMetroidPrime1CombatHudAnchorCandidate(metroid_layer, metroid_hud_ref_z,
                                                             metroid_hud_context));
                geometry_shader_manager.vr_metroid_hud_reference_context = metroid_hud_context;
              }
              if (element_depth >= 0.0f)
                geometry_shader_manager.vr_element_depth_override = element_depth;
              if (metroid_hydra_hud.enabled)
              {
                if (metroid_hydra_hud.scale > 0.0f)
                {
                  geometry_shader_manager.vr_units_per_meter_override =
                      g_ActiveConfig.vr_units_per_meter * metroid_hydra_hud.scale;
                }
                geometry_shader_manager.vr_headlocked_projection_scale_x =
                    metroid_hydra_hud.width;
                geometry_shader_manager.vr_headlocked_projection_scale_y =
                    metroid_hydra_hud.height;
                geometry_shader_manager.vr_headlocked_projection_offset_x =
                    metroid_hydra_hud.right;
                geometry_shader_manager.vr_headlocked_projection_offset_y = metroid_hydra_hud.up;
              }
            }
            else if (handling == ShaderHunter::HandlingType::UnitsPerMeter)
            {
              if (units_per_meter > 0.0f)
                geometry_shader_manager.vr_units_per_meter_override = units_per_meter;
            }
            else if (handling == ShaderHunter::HandlingType::Passthrough)
            {
              // PS-side only: the draw keeps its normal projection; its pixels write the
              // override's opacity into the coverage target, becoming a camera window.
              pixel_shader_manager.SetVRPassthroughAlpha(
                  std::clamp(passthrough_opacity, 0.0f, 1.0f));
            }
            else if (handling == ShaderHunter::HandlingType::CameraAnchor)
            {
              // The element's object-space origin in game view space (game units): the
              // translation column of the current position matrix. Captured as this frame's
              // pending anchor; OpenXRManager latches it at frame end so all draws of the
              // NEXT frame render from it (never mid-frame). The draw itself renders
              // normally unless the override hides it. Gating capture (not application) on
              // the toggle means disabling glides the camera back to the default position.
              if (g_ActiveConfig.stereo_mode == StereoMode::OpenXR && !vr_flat_mode &&
                  g_ActiveConfig.vr_enable_camera_anchor && VR::g_openxr &&
                  VR::g_openxr->IsSessionRunning())
              {
                const auto& pnm = vertex_shader_manager.constants.posnormalmatrix;
                // Convert the meter offsets with the scale actually in effect (which the
                // anchor itself may be driving), so they stay the requested real-world size
                // while an anchor scale glides in.
                const float upm = VR::g_openxr->GetEffectiveUnitsPerMeter();
                // Offset is {right, up, forward} in meters; view space is +X right, +Y up,
                // -Z forward (same convention as the Camera Forward/Height settings).
                const float ax = pnm[0][3] + anchor_params.offset[0] * upm;
                const float ay = pnm[1][3] + anchor_params.offset[1] * upm;
                const float az = pnm[2][3] - anchor_params.offset[2] * upm;
                // Rig rotation (columns = rig axes in view space). The element's object axes
                // in view space are the columns of the matrix's 3x3 block; the yaw offset
                // corrects models whose forward axis is not object +Z. Scale is removed by
                // the orthonormalization in CommitCameraAnchorFrame.
                constexpr float DEG_TO_RAD = 0.01745329252f;
                std::array<float, 9> anchor_rot = {1.0f, 0.0f, 0.0f, 0.0f, 1.0f,
                                                   0.0f, 0.0f, 0.0f, 1.0f};
                if (anchor_params.rotation == ShaderHunter::AnchorRotationMode::Full)
                {
                  const float yaw = anchor_params.yaw_offset_deg * DEG_TO_RAD;
                  const float cy = std::cos(yaw);
                  const float sy = std::sin(yaw);
                  // A = M_element * RotY(yaw): the correction spins the rig about the
                  // element's own up axis before mapping into view space.
                  for (int r = 0; r < 3; ++r)
                  {
                    anchor_rot[r * 3 + 0] = pnm[r][0] * cy - pnm[r][2] * sy;
                    anchor_rot[r * 3 + 1] = pnm[r][1];
                    anchor_rot[r * 3 + 2] = pnm[r][0] * sy + pnm[r][2] * cy;
                  }
                }
                else if (anchor_params.rotation == ShaderHunter::AnchorRotationMode::YawOnly)
                {
                  // Heading of the element's object +Z axis in the view's horizontal plane;
                  // pitch/roll are dropped so the horizon stays level (comfort).
                  const float vx = pnm[0][2];
                  const float vz = pnm[2][2];
                  float yaw = (vx * vx + vz * vz > 1e-8f) ? std::atan2(vx, vz) : 0.0f;
                  yaw += anchor_params.yaw_offset_deg * DEG_TO_RAD;
                  const float cy = std::cos(yaw);
                  const float sy = std::sin(yaw);
                  anchor_rot = {cy, 0.0f, sy, 0.0f, 1.0f, 0.0f, -sy, 0.0f, cy};
                }
                VR::g_openxr->SetPendingCameraAnchor(ax, ay, az, anchor_rot,
                                                     anchor_params.units_per_meter);
                if (hunter_debug_logging)
                {
                  INFO_LOG_FMT(VIDEO,
                               "VR_ANCHOR: draw#{} pos=({:.2f},{:.2f},{:.2f}) offset_m=({:.2f},"
                               "{:.2f},{:.2f}) rot={} yaw_off={:.0f} upm={:.2f}(eff {:.2f}) "
                               "hide={}",
                               m_draw_counter, pnm[0][3], pnm[1][3], pnm[2][3],
                               anchor_params.offset[0], anchor_params.offset[1],
                               anchor_params.offset[2],
                               static_cast<int>(anchor_params.rotation),
                               anchor_params.yaw_offset_deg, anchor_params.units_per_meter, upm,
                               anchor_params.hide);
                }
                if (anchor_params.hide)
                  elements_skip = true;
              }
            }
            else if (handling == ShaderHunter::HandlingType::ControllerAnchor)
            {
              // The element is repositioned to a VR controller: the position matrix
              // translation is replaced with the controller's aim pose mapped into game
              // view space (same space/units as the projection's eye offsets), plus the
              // override's meter offsets. With rotation follow the 3x3 (and normal rows)
              // are rebuilt from the controller orientation too; otherwise orientation
              // stays game-driven. Scale is always preserved. SetPosNormalChanged makes
              // the next flush reload the real matrix from XF memory so the write lives
              // for exactly one draw. Draws with per-vertex position-matrix indices
              // (posmtx) ignore posnormalmatrix entirely — the log flags those so a
              // non-moving element is diagnosable immediately.
              if (g_ActiveConfig.stereo_mode == StereoMode::OpenXR && !vr_flat_mode &&
                  g_ActiveConfig.vr_enable_controller_anchor && VR::g_openxr &&
                  VR::g_openxr->IsSessionRunning())
              {
                // Same scale the camera is using this frame (a Camera Anchor may be driving
                // it), or the hands would land at the wrong distance in the anchored view.
                const float upm = VR::g_openxr->GetEffectiveUnitsPerMeter();
                std::array<float, 3> hand_pos{};
                std::array<float, 9> hand_rot{};
                if (VR::g_openxr->GetControllerAnchorViewPose(controller_anchor_params.hand, upm,
                                                              &hand_pos, &hand_rot))
                {
                  auto& pnm = vertex_shader_manager.constants.posnormalmatrix;
                  const float old_x = pnm[0][3], old_y = pnm[1][3], old_z = pnm[2][3];
                  const float off_x = controller_anchor_params.offset[0] * upm;
                  const float off_y = controller_anchor_params.offset[1] * upm;
                  const float off_z = -controller_anchor_params.offset[2] * upm;
                  float dx = off_x, dy = off_y, dz = off_z;
                  if (controller_anchor_params.rotation)
                  {
                    // Offsets ride the controller frame so the element stays rigidly
                    // attached (a view-space offset would drift around the grip as the
                    // hand turns).
                    dx = hand_rot[0] * off_x + hand_rot[1] * off_y + hand_rot[2] * off_z;
                    dy = hand_rot[3] * off_x + hand_rot[4] * off_y + hand_rot[5] * off_z;
                    dz = hand_rot[6] * off_x + hand_rot[7] * off_y + hand_rot[8] * off_z;
                  }
                  pnm[0][3] = hand_pos[0] + dx;
                  pnm[1][3] = hand_pos[1] + dy;
                  pnm[2][3] = hand_pos[2] + dz;
                  if (controller_anchor_params.rotation)
                  {
                    // 3x3 = (A*C)*X: controller orientation in view space times the
                    // model-axis correction. The game matrix's per-axis scale (column
                    // norms) is preserved so the model keeps its size; the normal rows
                    // get the pure rotation (the correct inverse-transpose for a rigid
                    // transform, and stale game normals would light the element wrong
                    // as it turns).
                    const std::array<float, 9> m = Mul3x3(
                        hand_rot, ControllerAnchorAxisCorrection(controller_anchor_params.yaw_deg,
                                                                 controller_anchor_params.pitch_deg,
                                                                 controller_anchor_params.roll_deg));
                    for (int c = 0; c < 3; ++c)
                    {
                      const float len =
                          std::sqrt(pnm[0][c] * pnm[0][c] + pnm[1][c] * pnm[1][c] +
                                    pnm[2][c] * pnm[2][c]);
                      const float s = len > 1e-6f ? len : 1.0f;
                      pnm[0][c] = m[0 + c] * s;
                      pnm[1][c] = m[3 + c] * s;
                      pnm[2][c] = m[6 + c] * s;
                      pnm[3][c] = m[0 + c];
                      pnm[4][c] = m[3 + c];
                      pnm[5][c] = m[6 + c];
                    }
                  }
                  vertex_shader_manager.dirty = true;
                  xf_state_manager.SetPosNormalChanged();
                  if (hunter_debug_logging)
                  {
                    const NativeVertexFormat* fmt = VertexLoaderManager::GetCurrentVertexFormat();
                    const bool posmtx = fmt && fmt->GetVertexDeclaration().posmtx.enable;
                    INFO_LOG_FMT(VIDEO,
                                 "VR_HANDANCHOR: draw#{} hand={} posmtx={} rot={} "
                                 "old=({:.2f},{:.2f},{:.2f}) new=({:.2f},{:.2f},{:.2f})",
                                 m_draw_counter, controller_anchor_params.hand == 0 ? "L" : "R",
                                 posmtx ? 1 : 0, controller_anchor_params.rotation ? 1 : 0, old_x,
                                 old_y, old_z, pnm[0][3], pnm[1][3], pnm[2][3]);
                  }
                }
                else if (hunter_debug_logging)
                {
                  INFO_LOG_FMT(VIDEO, "VR_HANDANCHOR: draw#{} hand={} pose unavailable",
                               m_draw_counter, controller_anchor_params.hand == 0 ? "L" : "R");
                }
              }
            }
            else
            {
              // No override matched — log for debugging if relevant
              hunter.DebugLogUnmatched(vs_hash, ps_hash, gs_hash);
            }
          }

          // ClearEFB is an independent flag, checked regardless of handling type.
          // This lets an element be e.g. Skip+ClearEFB or Screen+ClearEFB.
          if (elements_has_overrides)
            elements.CheckClearEFBForDraw(*element_draw);

          // VR Draw Debug Logging: log every draw call's projection, viewport, scissor, and
          // shader hashes so we can identify how specific visual elements (e.g. cinematic bars)
          // are drawn.
          if (hunter.IsDebugLogging()) [[unlikely]]
          {
            const auto& proj = xfmem.projection;
            const auto& vp = xfmem.viewport;
            const auto& scTL = bpmem.scissorTL;
            const auto& scBR = bpmem.scissorBR;
            const u32 nidx = m_index_generator.GetIndexLen();
            const bool z_test = bpmem.zmode.test_enable != 0;
            const bool color_update = bpmem.blendmode.color_update != 0;
            const bool alpha_update = bpmem.blendmode.alpha_update != 0;
            const bool z_update = bpmem.zmode.update_enable != 0;
            if (proj.type == ProjectionType::Orthographic)
            {
              const float* p = proj.rawProjection.data();
              const float left = -(p[1] + 1) / p[0];
              const float right = left + 2 / p[0];
              const float bottom = -(p[3] + 1) / p[2];
              const float top = bottom + 2 / p[2];
              const float zfar = p[5] / p[4];
              const float znear = (1 + p[4] * zfar) / p[4];
              INFO_LOG_FMT(VIDEO,
                           "VR_DRAW #{}: ORTHO l={:.1f} r={:.1f} t={:.1f} b={:.1f} n={:.1f} "
                           "f={:.1f} | VP({:.0f},{:.0f} {:.0f}x{:.0f}) | SC({},{} {},{})"
                           " | VS={:08x} PS={:08x} GS={:08x} | idx={} col={} alpha={} zt={} "
                           "z={} zf={} | skip={}",
                           m_draw_counter, left, right, top, bottom, znear, zfar, vp.xOrig,
                           vp.yOrig, vp.wd, vp.ht, scTL.x, scTL.y, scBR.x, scBR.y, vs_hash,
                           ps_hash, gs_hash, nidx, color_update, alpha_update, z_test, z_update,
                           bpmem.zmode.func, hunter_skip);
            }
            else
            {
              const float* p = proj.rawProjection.data();
              const float hfov = 2 * std::atan(1.0f / p[0]) * 180.0f / 3.14159265f;
              const float vfov = 2 * std::atan(1.0f / p[2]) * 180.0f / 3.14159265f;
              const float f = p[5] / p[4];
              const float n = f * p[4] / (p[4] - 1);
              INFO_LOG_FMT(VIDEO,
                           "VR_DRAW #{}: PERSP hfov={:.2f} vfov={:.2f} n={:.2f} f={:.2f}"
                           " | VP({:.0f},{:.0f} {:.0f}x{:.0f}) | SC({},{} {},{})"
                           " | VS={:08x} PS={:08x} GS={:08x} | idx={} col={} alpha={} zt={} "
                           "z={} zf={} | skip={}",
                           m_draw_counter, hfov, vfov, n, f, vp.xOrig, vp.yOrig, vp.wd, vp.ht,
                           scTL.x, scTL.y, scBR.x, scBR.y, vs_hash, ps_hash, gs_hash, nidx,
                           color_update, alpha_update, z_test, z_update, bpmem.zmode.func,
                           hunter_skip);
            }
          }
        }

        // Auto-detect EFB-copy effects: bloom, motion blur, and post-processing draw as ortho
        // quads sampling textures the game just copied out of the EFB, so the virtual-screen
        // path would capture them and smear a whole-scene effect across the 2D screen. When
        // such a draw has no explicit override, render it natively into both eye layers
        // instead (same as a manual Fullscreen override). Downscaled copies are effect
        // buffers by construction; full-resolution copies qualify only when blended over the
        // scene, so opaque frozen-frame quads (pause-menu backgrounds) stay on the screen.
        if (g_ActiveConfig.stereo_mode == StereoMode::OpenXR && !vr_flat_mode &&
            g_ActiveConfig.vr_virtual_screen && g_ActiveConfig.vr_auto_native_efb_effects &&
            !hunter_skip && !elements_skip && !texmgr_skip &&
            std::isnan(geometry_shader_manager.vr_stereo_override) &&
            xfmem.projection.type != ProjectionType::Perspective)
        {
          const bool blend_active = bpmem.blendmode.blend_enable || bpmem.blendmode.subtract;
          for (const u32 i : used_textures)
          {
            u32 copy_width = 0;
            u32 copy_height = 0;
            if (!g_texture_cache->IsBoundEfbCopy(i, &copy_width, &copy_height))
              continue;
            const bool downscaled =
                copy_width * 2 <= EFB_WIDTH && copy_height * 2 <= EFB_HEIGHT;
            if (downscaled || blend_active)
            {
              geometry_shader_manager.vr_stereo_override = 0.0f;
              break;
            }
          }
        }

        // Exact virtual-screen depth: swap in the depth-exporting PS variant for draws that land
        // on the VR virtual screen (Screen/HeadLocked overrides and natural ortho draws). The PS
        // then writes the game's flat-screen depth from the flat-interpolated VS capture,
        // restoring GX's deterministic equal-depth semantics (fixes menu z-fighting). This runs
        // AFTER the hunter hashes were computed, so signature hashes stay stable regardless of
        // the toggle. The -3.0 Metroid perspective-HUD path keeps its own depth handling.
        if (g_ActiveConfig.stereo_mode == StereoMode::OpenXR &&
            g_ActiveConfig.vr_exact_screen_depth)
        {
          const float stereo_ovr = geometry_shader_manager.vr_stereo_override;
          const bool forced_screen =
              !std::isnan(stereo_ovr) && (stereo_ovr == -1.0f || stereo_ovr == -2.0f);
          const bool natural_ortho = std::isnan(stereo_ovr) &&
                                     xfmem.projection.type != ProjectionType::Perspective &&
                                     g_ActiveConfig.vr_virtual_screen;
          if (forced_screen || natural_ortho)
          {
            auto* const ps_uid_data = m_current_pipeline_config.ps_uid.GetUidData();
            auto* const uber_ps_uid_data = m_current_uber_pipeline_config.ps_uid.GetUidData();
            if (!ps_uid_data->vr_screen_exact_depth || !uber_ps_uid_data->vr_screen_exact_depth)
            {
              ps_uid_data->vr_screen_exact_depth = 1;
              uber_ps_uid_data->vr_screen_exact_depth = 1;
              m_pipeline_config_changed = true;
              UpdatePipelineObject();
            }
          }
        }

        if (!hunter_skip && !elements_skip && !texmgr_skip)
        {
          if (shader_hunter_force_pink && !m_pink_pixel_shader)
          {
            // Simple PS that outputs solid magenta, like 3DMigoto's hunting mode.
            // No #version or #defines — the backend prepends its own SHADER_HEADER
            // (with #version 450, type aliases, etc.) before SPIRV compilation.
            // Outputs both ocol0 and ocol1 (dual-source blending index 1) so shaders
            // using SRC1_ALPHA blend modes still render visibly.
            constexpr std::string_view pink_source =
                "FRAGMENT_OUTPUT_LOCATION_INDEXED(0, 0) out float4 ocol0;\n"
                "FRAGMENT_OUTPUT_LOCATION_INDEXED(0, 1) out float4 ocol1;\n"
                "void main() {\n"
                "  ocol0 = float4(1.0, 0.0, 1.0, 1.0);\n"
                "  ocol1 = float4(0.0, 0.0, 0.0, 1.0);\n"
                "}\n";
            m_pink_pixel_shader = g_gfx->CreateShaderFromSource(
                ShaderStage::Pixel, pink_source, nullptr, "Pink Highlight");
            if (!m_pink_pixel_shader)
              WARN_LOG_FMT(VIDEO, "Failed to compile pink highlight pixel shader");
          }
          m_force_pink_ps = shader_hunter_force_pink;

          const AbstractPipeline* pipeline_object = m_current_pipeline_object;
          if (!custom_pixel_shader_contents.shaders.empty())
          {
            const AbstractPipeline* custom_pipeline = nullptr;
            if (const auto async_pipeline =
                    GetCustomPipeline(custom_pixel_shader_contents, m_current_pipeline_config,
                                      m_current_uber_pipeline_config, m_current_pipeline_object))
            {
              custom_pipeline = async_pipeline;
            }

            if (custom_pipeline)
            {
              pipeline_object = custom_pipeline;
            }
          }
          RenderDrawCall(pixel_shader_manager, geometry_shader_manager,
                         custom_pixel_shader_contents, custom_pixel_shader_uniforms,
                         m_current_primitive_type, pipeline_object);
          m_force_pink_ps = false;
        }
      }
    }

    if (!committed_hide_object_capture)
      HideObjectEngine::Engine::GetInstance().DiscardPendingCapturedPrefixes();

    // Even if we skip the draw, emulated state should still be impacted
    OnDraw();

    // The EFB cache is now potentially stale.
    g_framebuffer_manager->FlagPeekCacheAsOutOfDate();
  }
  else
  {
    HideObjectEngine::Engine::GetInstance().DiscardPendingCapturedPrefixes();
  }

  if (xfmem.numTexGen.numTexGens != bpmem.genMode.numtexgens)
  {
    ERROR_LOG_FMT(VIDEO,
                  "xf.numtexgens ({}) does not match bp.numtexgens ({}). Error in command stream.",
                  xfmem.numTexGen.numTexGens, bpmem.genMode.numtexgens.Value());
  }
}

void VertexManagerBase::DoState(PointerWrap& p)
{
  if (p.IsReadMode())
  {
    // Flush old vertex data before loading state.
    Flush();
  }

  p.Do(m_zslope);
  p.Do(VertexLoaderManager::normal_cache);
  p.Do(VertexLoaderManager::tangent_cache);
  p.Do(VertexLoaderManager::binormal_cache);
}

void VertexManagerBase::CalculateZSlope(NativeVertexFormat* format)
{
  float out[12];
  float viewOffset[2] = {xfmem.viewport.xOrig - bpmem.scissorOffset.x * 2,
                         xfmem.viewport.yOrig - bpmem.scissorOffset.y * 2};

  if (m_current_primitive_type != PrimitiveType::Triangles &&
      m_current_primitive_type != PrimitiveType::TriangleStrip)
  {
    return;
  }

  // Global matrix ID.
  u32 mtxIdx = g_main_cp_state.matrix_index_a.PosNormalMtxIdx;
  const PortableVertexDeclaration vert_decl = format->GetVertexDeclaration();

  // Make sure the buffer contains at least 3 vertices.
  if ((m_cur_buffer_pointer - m_base_buffer_pointer) < (vert_decl.stride * 3))
    return;

  // Lookup vertices of the last rendered triangle and software-transform them
  // This allows us to determine the depth slope, which will be used if z-freeze
  // is enabled in the following flush.
  auto& system = Core::System::GetInstance();
  auto& vertex_shader_manager = system.GetVertexShaderManager();
  for (unsigned int i = 0; i < 3; ++i)
  {
    // If this vertex format has per-vertex position matrix IDs, look it up.
    if (vert_decl.posmtx.enable)
      mtxIdx = VertexLoaderManager::position_matrix_index_cache[2 - i];

    if (vert_decl.position.components == 2)
      VertexLoaderManager::position_cache[2 - i][2] = 0;

    vertex_shader_manager.TransformToClipSpace(&VertexLoaderManager::position_cache[2 - i][0],
                                               &out[i * 4], mtxIdx);

    // Transform to Screenspace
    float inv_w = 1.0f / out[3 + i * 4];

    out[0 + i * 4] = out[0 + i * 4] * inv_w * xfmem.viewport.wd + viewOffset[0];
    out[1 + i * 4] = out[1 + i * 4] * inv_w * xfmem.viewport.ht + viewOffset[1];
    out[2 + i * 4] = out[2 + i * 4] * inv_w * xfmem.viewport.zRange + xfmem.viewport.farZ;
  }

  float dx31 = out[8] - out[0];
  float dx12 = out[0] - out[4];
  float dy12 = out[1] - out[5];
  float dy31 = out[9] - out[1];

  float DF31 = out[10] - out[2];
  float DF21 = out[6] - out[2];
  float a = DF31 * -dy12 - DF21 * dy31;
  float b = dx31 * DF21 + dx12 * DF31;
  float c = -dx12 * dy31 - dx31 * -dy12;

  // Sometimes we process de-generate triangles. Stop any divide by zeros
  if (c == 0)
    return;

  m_zslope.dfdx = -a / c;
  m_zslope.dfdy = -b / c;
  m_zslope.f0 = out[2] - (out[0] * m_zslope.dfdx + out[1] * m_zslope.dfdy);
  m_zslope.dirty = true;
}

void VertexManagerBase::CalculateNormals(NativeVertexFormat* format)
{
  const PortableVertexDeclaration vert_decl = format->GetVertexDeclaration();

  // Only update the binormal/tangent vertex shader constants if the vertex format lacks binormals
  // (VertexLoaderManager::binormal_cache gets updated by the vertex loader when binormals are
  // present, though)
  if (vert_decl.normals[1].enable)
    return;

  VertexLoaderManager::tangent_cache[3] = 0;
  VertexLoaderManager::binormal_cache[3] = 0;

  auto& system = Core::System::GetInstance();
  auto& vertex_shader_manager = system.GetVertexShaderManager();
  if (vertex_shader_manager.constants.cached_tangent != VertexLoaderManager::tangent_cache)
  {
    vertex_shader_manager.constants.cached_tangent = VertexLoaderManager::tangent_cache;
    vertex_shader_manager.dirty = true;
  }
  if (vertex_shader_manager.constants.cached_binormal != VertexLoaderManager::binormal_cache)
  {
    vertex_shader_manager.constants.cached_binormal = VertexLoaderManager::binormal_cache;
    vertex_shader_manager.dirty = true;
  }

  if (vert_decl.normals[0].enable)
    return;

  VertexLoaderManager::normal_cache[3] = 0;
  if (vertex_shader_manager.constants.cached_normal != VertexLoaderManager::normal_cache)
  {
    vertex_shader_manager.constants.cached_normal = VertexLoaderManager::normal_cache;
    vertex_shader_manager.dirty = true;
  }
}

void VertexManagerBase::UpdatePipelineConfig()
{
  NativeVertexFormat* vertex_format = VertexLoaderManager::GetCurrentVertexFormat();
  if (vertex_format != m_current_pipeline_config.vertex_format)
  {
    m_current_pipeline_config.vertex_format = vertex_format;
    m_current_uber_pipeline_config.vertex_format =
        VertexLoaderManager::GetUberVertexFormat(vertex_format->GetVertexDeclaration());
    m_pipeline_config_changed = true;
  }

  VertexShaderUid vs_uid = GetVertexShaderUid();
  if (vs_uid != m_current_pipeline_config.vs_uid)
  {
    m_current_pipeline_config.vs_uid = vs_uid;
    m_current_uber_pipeline_config.vs_uid = UberShader::GetVertexShaderUid();
    m_pipeline_config_changed = true;
  }

  PixelShaderUid ps_uid = GetPixelShaderUid();
  if (ps_uid != m_current_pipeline_config.ps_uid)
  {
    m_current_pipeline_config.ps_uid = ps_uid;
    m_current_uber_pipeline_config.ps_uid = UberShader::GetPixelShaderUid();
    m_pipeline_config_changed = true;
  }

  GeometryShaderUid gs_uid = GetGeometryShaderUid(GetCurrentPrimitiveType());
  if (gs_uid != m_current_pipeline_config.gs_uid)
  {
    m_current_pipeline_config.gs_uid = gs_uid;
    m_current_uber_pipeline_config.gs_uid = gs_uid;
    m_pipeline_config_changed = true;
  }

  if (m_rasterization_state_changed)
  {
    m_rasterization_state_changed = false;

    RasterizationState new_rs = {};
    new_rs.Generate(bpmem, m_current_primitive_type);
    if (new_rs != m_current_pipeline_config.rasterization_state)
    {
      m_current_pipeline_config.rasterization_state = new_rs;
      m_current_uber_pipeline_config.rasterization_state = new_rs;
      m_pipeline_config_changed = true;
    }
  }

  if (m_depth_state_changed)
  {
    m_depth_state_changed = false;

    DepthState new_ds = {};
    new_ds.Generate(bpmem);
    if (new_ds != m_current_pipeline_config.depth_state)
    {
      m_current_pipeline_config.depth_state = new_ds;
      m_current_uber_pipeline_config.depth_state = new_ds;
      m_pipeline_config_changed = true;
    }
  }

  if (m_blending_state_changed)
  {
    m_blending_state_changed = false;

    BlendingState new_bs = {};
    new_bs.Generate(bpmem);
    if (new_bs != m_current_pipeline_config.blending_state)
    {
      m_current_pipeline_config.blending_state = new_bs;
      m_current_uber_pipeline_config.blending_state = new_bs;
      m_pipeline_config_changed = true;
    }
  }
}

void VertexManagerBase::UpdatePipelineObject()
{
  if (!m_pipeline_config_changed)
    return;

  m_current_pipeline_object = nullptr;
  m_current_pipeline_is_uber = false;
  m_pipeline_config_changed = false;

  switch (g_ActiveConfig.iShaderCompilationMode)
  {
  case ShaderCompilationMode::Synchronous:
  {
    // Ubershaders disabled? Block and compile the specialized shader.
    m_current_pipeline_object = g_shader_cache->GetPipelineForUid(m_current_pipeline_config);
  }
  break;

  case ShaderCompilationMode::SynchronousUberShaders:
  {
    // Exclusive ubershader mode, always use ubershaders.
    m_current_pipeline_is_uber = true;
    m_current_pipeline_object =
        g_shader_cache->GetUberPipelineForUid(m_current_uber_pipeline_config);
  }
  break;

  case ShaderCompilationMode::AsynchronousUberShaders:
  case ShaderCompilationMode::AsynchronousSkipRendering:
  {
    // Can we background compile shaders? If so, get the pipeline asynchronously.
    auto res = g_shader_cache->GetPipelineForUidAsync(m_current_pipeline_config);
    if (res)
    {
      // Specialized shaders are ready, prefer these.
      m_current_pipeline_object = *res;
      return;
    }

    if (g_ActiveConfig.iShaderCompilationMode == ShaderCompilationMode::AsynchronousUberShaders)
    {
      // Specialized shaders not ready, use the ubershaders.
      m_current_pipeline_is_uber = true;
      m_current_pipeline_object =
          g_shader_cache->GetUberPipelineForUid(m_current_uber_pipeline_config);
    }
    else
    {
      // Ensure we try again next draw. Otherwise, if no registers change between frames, the
      // object will never be drawn, even when the shader is ready.
      m_pipeline_config_changed = true;
    }
  }
  break;
  }
}

void VertexManagerBase::OnConfigChange()
{
  // Reload index generator function tables in case VS expand config changed
  m_index_generator.Init();
}

void VertexManagerBase::OnDraw()
{
  m_draw_counter++;

  // If the last efb copy was too close to the one before it, don't forget about it until the next
  // efb copy happens (which might not be for a long time)
  u32 diff = m_draw_counter - m_last_efb_copy_draw_counter;
  if (m_unflushed_efb_copy && diff > MINIMUM_DRAW_CALLS_PER_COMMAND_BUFFER_FOR_READBACK)
  {
    g_gfx->Flush();
    m_unflushed_efb_copy = false;
    m_last_efb_copy_draw_counter = m_draw_counter;
  }

  // If we didn't have any CPU access last frame, do nothing.
  if (m_scheduled_command_buffer_kicks.empty() || !m_allow_background_execution)
    return;

  // Check if this draw is scheduled to kick a command buffer.
  // The draw counters will always be sorted so a binary search is possible here.
  if (std::ranges::binary_search(m_scheduled_command_buffer_kicks, m_draw_counter))
  {
    // Kick a command buffer on the background thread.
    g_gfx->Flush();
    m_unflushed_efb_copy = false;
    m_last_efb_copy_draw_counter = m_draw_counter;
  }
}

void VertexManagerBase::OnCPUEFBAccess()
{
  // Check this isn't another access without any draws in between.
  if (!m_cpu_accesses_this_frame.empty() && m_cpu_accesses_this_frame.back() == m_draw_counter)
    return;

  // Store the current draw counter for scheduling in OnEndFrame.
  m_cpu_accesses_this_frame.emplace_back(m_draw_counter);
}

void VertexManagerBase::OnEFBCopyToRAM()
{
  // If we're not deferring, try to preempt it next frame.
  if (!g_ActiveConfig.bDeferEFBCopies)
  {
    OnCPUEFBAccess();
    return;
  }

  // Otherwise, only execute if we have at least 10 objects between us and the last copy.
  const u32 diff = m_draw_counter - m_last_efb_copy_draw_counter;
  m_last_efb_copy_draw_counter = m_draw_counter;
  if (diff < MINIMUM_DRAW_CALLS_PER_COMMAND_BUFFER_FOR_READBACK)
  {
    m_unflushed_efb_copy = true;
    return;
  }

  m_unflushed_efb_copy = false;
  g_gfx->Flush();
}

void VertexManagerBase::OnEndFrame()
{
  auto& hunter = ShaderHunter::GetInstance();
  // Lazy-load shader overrides and hide object codes when game ID becomes available or changes
  const std::string game_id = SConfig::GetInstance().GetGameID();
  if (!game_id.empty())
  {
    hunter.LoadOverridesIfNeeded(game_id);
    ElementsGroupManager::GetInstance().LoadOverridesIfNeeded(game_id);
    TextureElementManager::GetInstance().LoadOverridesIfNeeded(game_id);
    HideObjectEngine::Engine::GetInstance().LoadCodesIfNeeded(game_id);
  }
  hunter.OnFrameEnd();
  CullingCodeFinder::GetInstance().OnFrameEnd();
  ElementsGroupManager::GetInstance().OnFrameEnd();
  if (VR::g_openxr)
    VR::g_openxr->CommitCameraAnchorFrame();
  TextureElementManager::GetInstance().OnFrameEnd();
  HideObjectEngine::Engine::GetInstance().OnFrameEnd();
  GetMetroidElementClassifier().ResetFrame();
  m_metroid_prime1_combat_context_seen = false;
  m_metroid_prime1_menu_context_seen = false;
  m_draw_counter = 0;
  m_last_efb_copy_draw_counter = 0;
  m_scheduled_command_buffer_kicks.clear();

  // If we have no CPU access at all, leave everything in the one command buffer for maximum
  // parallelism between CPU/GPU, at the cost of slightly higher latency.
  if (m_cpu_accesses_this_frame.empty())
    return;

  // In order to reduce CPU readback latency, we want to kick a command buffer roughly halfway
  // between the draw counters that invoked the readback, or every 250 draws, whichever is
  // smaller.
  if (g_ActiveConfig.iCommandBufferExecuteInterval > 0)
  {
    u32 last_draw_counter = 0;
    u32 interval = static_cast<u32>(g_ActiveConfig.iCommandBufferExecuteInterval);
    for (u32 draw_counter : m_cpu_accesses_this_frame)
    {
      // We don't want to waste executing command buffers for only a few draws, so set a minimum.
      // Leave last_draw_counter as-is, so we get the correct number of draws between submissions.
      u32 draw_count = draw_counter - last_draw_counter;
      if (draw_count < MINIMUM_DRAW_CALLS_PER_COMMAND_BUFFER_FOR_READBACK)
        continue;

      if (draw_count <= interval)
      {
        u32 mid_point = draw_count / 2;
        m_scheduled_command_buffer_kicks.emplace_back(last_draw_counter + mid_point);
      }
      else
      {
        u32 counter = interval;
        while (counter < draw_count)
        {
          m_scheduled_command_buffer_kicks.emplace_back(last_draw_counter + counter);
          counter += interval;
        }
      }

      last_draw_counter = draw_counter;
    }
  }

  m_cpu_accesses_this_frame.clear();

  // We invalidate the pipeline object at the start of the frame.
  // This is for the rare case where only a single pipeline configuration is used,
  // and hybrid ubershaders have compiled the specialized shader, but without any
  // state changes the specialized shader will not take over.
  InvalidatePipelineObject();
}

void VertexManagerBase::NotifyCustomShaderCacheOfHostChange(const ShaderHostConfig& host_config)
{
  m_custom_shader_cache->SetHostConfig(host_config);
  m_custom_shader_cache->Reload();
}

void VertexManagerBase::RenderDrawCall(
    PixelShaderManager& pixel_shader_manager, GeometryShaderManager& geometry_shader_manager,
    const CustomPixelShaderContents& custom_pixel_shader_contents,
    std::span<u8> custom_pixel_shader_uniforms, PrimitiveType primitive_type,
    const AbstractPipeline* current_pipeline)
{
  // Now we can upload uniforms, as nothing else will override them.
  geometry_shader_manager.SetConstants(primitive_type);
  pixel_shader_manager.SetConstants();
  if (!custom_pixel_shader_uniforms.empty() &&
      pixel_shader_manager.custom_constants.data() != custom_pixel_shader_uniforms.data())
  {
    pixel_shader_manager.custom_constants_dirty = true;
  }
  pixel_shader_manager.custom_constants = custom_pixel_shader_uniforms;
  UploadUniforms();

  u32 base_vertex, base_index;
  CommitBuffer(m_index_generator.GetNumVerts(),
               VertexLoaderManager::GetCurrentVertexFormat()->GetVertexStride(),
               m_index_generator.GetIndexLen(), &base_vertex, &base_index);

  if (g_backend_info.api_type != APIType::D3D && g_ActiveConfig.UseVSForLinePointExpand() &&
      (primitive_type == PrimitiveType::Points || primitive_type == PrimitiveType::Lines))
  {
    // VS point/line expansion puts the vertex id at gl_VertexID << 2
    // That means the base vertex has to be adjusted to match
    // (The shader adds this after shifting right on D3D, so no need to do this)
    base_vertex <<= 2;
  }

  VRPassthroughCoverageShaderMode coverage_mode =
      m_current_pipeline_is_uber ?
          m_current_uber_pipeline_config.ps_uid.GetUidData()->vr_coverage_mode :
          m_current_pipeline_config.ps_uid.GetUidData()->vr_coverage_mode;
  if (!custom_pixel_shader_contents.shaders.empty() &&
      g_framebuffer_manager->HasEFBCoverage())
  {
    coverage_mode = VRPassthroughCoverageShaderMode::Prepass;
  }

  if (coverage_mode == VRPassthroughCoverageShaderMode::Prepass)
  {
    const AbstractPipeline* const coverage_pipeline =
        m_current_pipeline_is_uber ?
            g_shader_cache->GetCoverageUberPipelineForUid(m_current_uber_pipeline_config) :
            g_shader_cache->GetCoveragePipelineForUid(m_current_pipeline_config);
    if (coverage_pipeline)
    {
      g_framebuffer_manager->BindEFBCoverageFramebuffer();
      g_gfx->SetPipeline(coverage_pipeline);
      DrawCurrentBatch(base_index, m_index_generator.GetIndexLen(), base_vertex);
    }
  }

  // All EFB draws share the with-coverage framebuffer whenever the coverage attachment
  // exists — non-MRT pipelines are built against the same attachment layout with a
  // write-masked attachment 1 (see GetGXPipelineConfig), so the render pass never has
  // to restart between draws (a per-switch GMEM store/load on tiler GPUs).
  if (g_framebuffer_manager->HasEFBCoverage())
    g_framebuffer_manager->BindEFBFramebufferWithCoverage();
  else
    g_framebuffer_manager->BindEFBFramebuffer();
  g_gfx->SetPipeline(current_pipeline);

  // Shader Hunter pink highlight: override PS after pipeline is set (like 3DMigoto).
  if (m_force_pink_ps && m_pink_pixel_shader)
    g_gfx->SetForcePixelShader(m_pink_pixel_shader.get());

  if (PerfQueryBase::ShouldEmulate())
    g_perf_query->EnableQuery(bpmem.zcontrol.early_ztest ? PQG_ZCOMP_ZCOMPLOC : PQG_ZCOMP);

  DrawCurrentBatch(base_index, m_index_generator.GetIndexLen(), base_vertex);

  // Track the total emulated state draws
  INCSTAT(g_stats.this_frame.num_draw_calls);

  if (PerfQueryBase::ShouldEmulate())
    g_perf_query->DisableQuery(bpmem.zcontrol.early_ztest ? PQG_ZCOMP_ZCOMPLOC : PQG_ZCOMP);
}

const AbstractPipeline* VertexManagerBase::GetCustomPipeline(
    const CustomPixelShaderContents& custom_pixel_shader_contents,
    const VideoCommon::GXPipelineUid& current_pipeline_config,
    const VideoCommon::GXUberPipelineUid& current_uber_pipeline_config,
    const AbstractPipeline* current_pipeline) const
{
  if (current_pipeline)
  {
    if (!custom_pixel_shader_contents.shaders.empty())
    {
      VideoCommon::GXPipelineUid custom_pipeline_config = current_pipeline_config;
      VideoCommon::GXUberPipelineUid custom_uber_pipeline_config =
          current_uber_pipeline_config;
      AbstractPipelineConfig custom_base_config = current_pipeline->m_config;
      if (g_framebuffer_manager->HasEFBCoverage())
      {
        custom_pipeline_config.ps_uid.GetUidData()->vr_coverage_mode =
            VRPassthroughCoverageShaderMode::Prepass;
        custom_uber_pipeline_config.ps_uid.GetUidData()->vr_coverage_mode =
            VRPassthroughCoverageShaderMode::Prepass;
        // Match the shared with-coverage render pass (attachment 1 write-masked; the
        // coverage itself comes from the separate prepass) so custom-shader draws don't
        // force a render pass restart either.
        custom_base_config.framebuffer_state = g_framebuffer_manager->GetEFBFramebufferState(true);
        custom_base_config.additional_blending_state = RenderState::GetNoColorWriteBlendState();
        custom_base_config.use_independent_blending = true;
      }

      CustomShaderInstance custom_shaders;
      custom_shaders.pixel_contents = custom_pixel_shader_contents;
      switch (g_ActiveConfig.iShaderCompilationMode)
      {
      case ShaderCompilationMode::Synchronous:
      case ShaderCompilationMode::AsynchronousSkipRendering:
      {
        if (auto pipeline = m_custom_shader_cache->GetPipelineAsync(
                custom_pipeline_config, custom_shaders, custom_base_config))
        {
          return *pipeline;
        }
      }
      break;
      case ShaderCompilationMode::SynchronousUberShaders:
      {
        // Custom pixel shader injection is only supported by specialized pixel shader generation.
        // Avoid custom ubershader fallback in this mode so behavior is consistent across backends.
        if (!custom_pixel_shader_contents.shaders.empty())
        {
          if (auto pipeline = m_custom_shader_cache->GetPipelineAsync(
                  custom_pipeline_config, custom_shaders, custom_base_config))
          {
            return *pipeline;
          }
        }
        else
        {
          // D3D has issues compiling large custom ubershaders, use specialized shaders instead.
          if (g_backend_info.api_type == APIType::D3D)
          {
            if (auto pipeline = m_custom_shader_cache->GetPipelineAsync(
                    custom_pipeline_config, custom_shaders, custom_base_config))
            {
              return *pipeline;
            }
          }
          else
          {
            if (auto pipeline = m_custom_shader_cache->GetPipelineAsync(
                    custom_uber_pipeline_config, custom_shaders, custom_base_config))
            {
              return *pipeline;
            }
          }
        }
      }
      break;
      case ShaderCompilationMode::AsynchronousUberShaders:
      {
        if (auto pipeline = m_custom_shader_cache->GetPipelineAsync(
                custom_pipeline_config, custom_shaders, custom_base_config))
        {
          return *pipeline;
        }
        // Custom pixel shader injection is only supported by specialized shaders.
        else if (custom_pixel_shader_contents.shaders.empty())
        {
          if (auto uber_pipeline = m_custom_shader_cache->GetPipelineAsync(
                  custom_uber_pipeline_config, custom_shaders, custom_base_config))
          {
            return *uber_pipeline;
          }
        }
      }
      break;
      };
    }
  }

  return nullptr;
}