[GPU] Double-buffer readback_resolve.

Introduce "fast" readback resolve that reads from previous frame's
resolve buffers, quick swap between buffers each frame to avoid
copies so minimal performance impact and mostly correct bahavior.
Checks if previous frame had a buffer for the current resolve and
falls through to the slow path, which also allows to support
"screenshot" features in the games that do that without stalling
on normal resolve operations.

Re-enaled readback_memexport as separate feature, was previously
bundled with readback_resolve (probably not intentionally) and
ensures destination address is committed on readback resolve to
avoid memory access related crashes.

readback_resolve cvar changes from bool to string ternary with
"none", "fast" and "full" options, defaulting to the new "fast"
mode.

Author: has207

src/xenia/app/emulator_window.cc

@@ -50,7 +50,7 @@ DECLARE_bool(guide_button);
 
 DECLARE_bool(clear_memory_page_state);
 
-DECLARE_bool(readback_resolve);
+DECLARE_string(readback_resolve);
 
 DECLARE_bool(readback_memexport);
 
@@ -1822,10 +1822,10 @@ EmulatorWindow::ControllerHotKey EmulatorWindow::ProcessControllerHotkey(
       xe::threading::Sleep(delay);
       break;
     case ButtonFunctions::ReadbackResolve:
-      ToggleGPUSetting(GPUSetting::ReadbackResolve);
+      CycleReadbackResolve();
 
-      notificationTitle = "Toggle Readback Resolve";
-      notificationDesc = cvars::readback_resolve ? "Enabled" : "Disabled";
+      notificationTitle = "Readback Resolve Mode";
+      notificationDesc = cvars::readback_resolve;
 
       // Extra Sleep
       xe::threading::Sleep(delay);
@@ -2009,15 +2009,23 @@ void EmulatorWindow::ToggleGPUSetting(gpu::GPUSetting setting) {
       SaveGPUSetting(GPUSetting::ClearMemoryPageState,
                      !cvars::clear_memory_page_state);
       break;
-    case GPUSetting::ReadbackResolve:
-      SaveGPUSetting(GPUSetting::ReadbackResolve, !cvars::readback_resolve);
-      break;
     case GPUSetting::ReadbackMemexport:
       SaveGPUSetting(GPUSetting::ReadbackMemexport, !cvars::readback_memexport);
       break;
   }
 }
 
+void EmulatorWindow::CycleReadbackResolve() {
+  const std::string& current = cvars::readback_resolve;
+  if (current == "fast") {
+    gpu::SetReadbackResolveMode("full");
+  } else if (current == "full") {
+    gpu::SetReadbackResolveMode("none");
+  } else {
+    gpu::SetReadbackResolveMode("fast");
+  }
+}
+
 void EmulatorWindow::DisplayHotKeysConfig() {
   std::string msg = "";
   std::string msg_passthru = "";
@@ -2056,8 +2064,7 @@ void EmulatorWindow::DisplayHotKeysConfig() {
   msg.insert(0, msg_passthru);
   msg += "\n";
 
-  msg += "Readback Resolve: " +
-         xe::string_util::BoolToString(cvars::readback_resolve);
+  msg += "Readback Resolve: " + cvars::readback_resolve;
   msg += "\n";
 
   msg += "Clear Memory Page State: " +

src/xenia/app/emulator_window.h

@@ -280,6 +280,7 @@ class EmulatorWindow {
                          bool vibrate = true);
   void GamepadHotKeys();
   void ToggleGPUSetting(gpu::GPUSetting setting);
+  void CycleReadbackResolve();
   void DisplayHotKeysConfig();
 
   static std::string CanonicalizeFileExtension(

src/xenia/gpu/command_processor.cc

@@ -48,11 +48,12 @@ DEFINE_bool(clear_memory_page_state, false,
             "for 'Team Ninja' Games to fix missing character models)",
             "GPU");
 
-DEFINE_bool(
-    readback_resolve, false,
-    "Read render-to-texture results on the CPU. This may be "
-    "needed in some games, for instance, for screenshots in saved games, but "
-    "causes mid-frame synchronization, so it has a huge performance impact.",
+DEFINE_string(
+    readback_resolve, "fast",
+    "Controls CPU readback of render-to-texture resolve results.\n"
+    " fast: Read from previous frame (1 frame delay, no GPU stall - default)\n"
+    " full: Wait for GPU to finish (accurate but slow, GPU-CPU sync stall)\n"
+    " none: Disable readback completely (some games render better without it)",
     "GPU");
 
 DEFINE_bool(
@@ -73,9 +74,6 @@ void SaveGPUSetting(GPUSetting setting, uint64_t value) {
     case GPUSetting::ClearMemoryPageState:
       OVERRIDE_bool(clear_memory_page_state, static_cast<bool>(value));
       break;
-    case GPUSetting::ReadbackResolve:
-      OVERRIDE_bool(readback_resolve, static_cast<bool>(value));
-      break;
     case GPUSetting::ReadbackMemexport:
       OVERRIDE_bool(readback_memexport, static_cast<bool>(value));
       break;
@@ -86,14 +84,28 @@ bool GetGPUSetting(GPUSetting setting) {
   switch (setting) {
     case GPUSetting::ClearMemoryPageState:
       return cvars::clear_memory_page_state;
-    case GPUSetting::ReadbackResolve:
-      return cvars::readback_resolve;
     case GPUSetting::ReadbackMemexport:
       return cvars::readback_memexport;
   }
   return false;
 }
 
+ReadbackResolveMode GetReadbackResolveMode() {
+  const std::string& mode = cvars::readback_resolve;
+  if (mode == "full") {
+    return ReadbackResolveMode::kFull;
+  } else if (mode == "none") {
+    return ReadbackResolveMode::kDisabled;
+  } else {
+    // Default to "fast" for any unrecognized value
+    return ReadbackResolveMode::kFast;
+  }
+}
+
+void SetReadbackResolveMode(const std::string& mode) {
+  OVERRIDE_string(readback_resolve, mode);
+}
+
 using namespace xe::gpu::xenos;
 
 CommandProcessor::CommandProcessor(GraphicsSystem* graphics_system,

src/xenia/gpu/command_processor.h

@@ -33,14 +33,18 @@ class ByteStream;
 
 namespace gpu {
 
-enum class GPUSetting {
-  ClearMemoryPageState,
-  ReadbackResolve,
-  ReadbackMemexport
+enum class GPUSetting { ClearMemoryPageState, ReadbackMemexport };
+
+enum class ReadbackResolveMode {
+  kDisabled,  // No readback (none)
+  kFast,      // Delayed sync, 1 frame behind (fast)
+  kFull       // Immediate sync with GPU stall (full)
 };
 
 void SaveGPUSetting(GPUSetting setting, uint64_t value);
 bool GetGPUSetting(GPUSetting setting);
+ReadbackResolveMode GetReadbackResolveMode();
+void SetReadbackResolveMode(const std::string& mode);
 
 class GraphicsSystem;
 class Shader;
@@ -162,6 +166,27 @@ class CommandProcessor {
 
   static constexpr uint32_t kReadbackBufferSizeIncrement = 16 * 1024 * 1024;
 
+  // Eviction policy constants for readback buffer cache
+  static constexpr size_t kMaxReadbackBuffers = 64;
+  static constexpr uint64_t kReadbackBufferEvictionAgeFrames = 60;
+
+  // Progressive alignment for readback buffers to avoid wasting memory
+  static inline uint32_t AlignReadbackBufferSize(uint32_t size) {
+    if (size < 1 * 1024 * 1024) {
+      return xe::align(size, 256u * 1024u);  // 256KB for < 1MB
+    } else if (size < 4 * 1024 * 1024) {
+      return xe::align(size, 1u * 1024u * 1024u);  // 1MB for < 4MB
+    } else {
+      return xe::align(size, kReadbackBufferSizeIncrement);  // 16MB for >= 4MB
+    }
+  }
+
+  // Generate a cache key for a specific resolve operation
+  static inline uint64_t MakeReadbackResolveKey(uint32_t address,
+                                                uint32_t length) {
+    return (uint64_t(address) << 32) | uint64_t(length);
+  }
+
   void WorkerThreadMain();
   virtual bool SetupContext() = 0;
   virtual void ShutdownContext() = 0;