controller.cc

Go to the documentation of this file.

#include "controller.h"
 
#include "app/application.h"
#include "app/platform/sdl_compat.h"
 
#if defined(__APPLE__)
#include <TargetConditionals.h>
#endif
 
#include <chrono>
#include <cstdio>
#include <cstdlib>
#include <string>
#include <vector>
 
#include "absl/status/status.h"
#include "app/editor/core/content_registry.h"
#include "app/editor/editor_manager.h"
#include "app/editor/events/core_events.h"
#include "app/editor/layout/layout_manager.h"
#include "app/emu/emulator.h"
#include "app/gfx/backend/renderer_factory.h"
#include "app/gfx/resource/arena.h"
#include "app/gui/automation/widget_id_registry.h"
#include "app/gui/core/background_renderer.h"
#include "app/gui/core/theme_manager.h"
#include "app/platform/iwindow.h"
#include "app/platform/timing.h"
#include "app/service/screenshot_utils.h"
#include "imgui/imgui.h"
#include "imgui/imgui_internal.h"
#include "util/ui_thread_queue.h"
#if defined(YAZE_ENABLE_IMGUI_TEST_ENGINE) && YAZE_ENABLE_IMGUI_TEST_ENGINE
#include "app/testing/test_manager.h"
#include "imgui_test_engine/imgui_te_engine.h"
#endif
#if defined(__APPLE__) && \
    (TARGET_OS_IPHONE == 1 || TARGET_IPHONE_SIMULATOR == 1)
#include "app/platform/ios/ios_platform_state.h"
#endif
 
namespace yaze {
 
namespace {
 
// ---------------------------------------------------------------------------
// Input diagnostics (off unless YAZE_DEBUG_INPUT_LOG is set).
//
// YAZE_DEBUG_INPUT_LOG=<path> appends one line per SDL mouse/key/window event
// and one line per frame in which ImGui's mouse state changed: buttons down,
// clicked/released, hovered window and ID, active ID, key mods and the open
// popup stack. Used to find where a click is lost between SDL and ImGui.
//
// YAZE_DEBUG_INPUT_SCRIPT=<path> replays "<ms> <action> <x> <y>" lines
// (action: move, ldown, lup, rdown, rup) through SDL_PushEvent, relative to
// the first frame, so a hidden instance can be clicked through the real SDL
// queue, event filter and ImGui SDL backend.
// ---------------------------------------------------------------------------
struct InputDebug {
  FILE* log = nullptr;
  struct Step {
    int at_ms;
    std::string action;
    float x;
    float y;
  };
  std::vector<Step> script;
  size_t next_step = 0;
  std::chrono::steady_clock::time_point start;
  bool started = false;
  std::string last_frame_line;
};
 
InputDebug& GetInputDebug() {
  static InputDebug* debug = [] {
    auto* d = new InputDebug();
    if (const char* path = std::getenv("YAZE_DEBUG_INPUT_LOG");
        path != nullptr && path[0] != '\0') {
      d->log = std::fopen(path, "a");
    }
    if (const char* path = std::getenv("YAZE_DEBUG_INPUT_SCRIPT");
        path != nullptr && path[0] != '\0') {
      if (FILE* f = std::fopen(path, "r")) {
        char action[32];
        int at = 0;
        float x = 0, y = 0;
        while (std::fscanf(f, "%d %31s %f %f", &at, action, &x, &y) == 4) {
          d->script.push_back({at, action, x, y});
        }
        std::fclose(f);
      }
    }
    return d;
  }();
  return *debug;
}
 
double InputDebugMs() {
  auto& d = GetInputDebug();
  return std::chrono::duration<double, std::milli>(
             std::chrono::steady_clock::now() - d.start)
      .count();
}
 
#ifndef YAZE_USE_SDL3
void InputDebugLogSdlEvent(const SDL_Event& e) {
  auto& d = GetInputDebug();
  if (d.log == nullptr) {
    return;
  }
  switch (e.type) {
    case SDL_MOUSEBUTTONDOWN:
    case SDL_MOUSEBUTTONUP:
      std::fprintf(d.log, "%9.1f sdl %s btn=%d x=%d y=%d win=%u clicks=%d\n",
                   InputDebugMs(),
                   e.type == SDL_MOUSEBUTTONDOWN ? "mousedown" : "mouseup",
                   e.button.button, e.button.x, e.button.y, e.button.windowID,
                   e.button.clicks);
      break;
    case SDL_KEYDOWN:
    case SDL_KEYUP:
      std::fprintf(d.log, "%9.1f sdl %s sym=0x%x mod=0x%x\n", InputDebugMs(),
                   e.type == SDL_KEYDOWN ? "keydown" : "keyup",
                   e.key.keysym.sym, e.key.keysym.mod);
      break;
    case SDL_WINDOWEVENT:
      std::fprintf(d.log, "%9.1f sdl window event=%d\n", InputDebugMs(),
                   e.window.event);
      break;
    default:
      break;
  }
}
 
void InputDebugRunScript() {
  auto& d = GetInputDebug();
  if (d.next_step >= d.script.size()) {
    return;
  }
  const ImGuiViewport* vp = ImGui::GetMainViewport();
  const Uint32 window_id =
      static_cast<Uint32>(reinterpret_cast<intptr_t>(vp->PlatformHandle));
  while (d.next_step < d.script.size() &&
         d.script[d.next_step].at_ms <= InputDebugMs()) {
    const auto& step = d.script[d.next_step++];
    SDL_Event ev{};
    const int x = static_cast<int>(step.x);
    const int y = static_cast<int>(step.y);
    if (step.action == "move") {
      ev.type = SDL_MOUSEMOTION;
      ev.motion.windowID = window_id;
      ev.motion.x = x;
      ev.motion.y = y;
    } else {
      const bool down = step.action == "ldown" || step.action == "rdown";
      ev.type = down ? SDL_MOUSEBUTTONDOWN : SDL_MOUSEBUTTONUP;
      ev.button.windowID = window_id;
      ev.button.button =
          step.action[0] == 'r' ? SDL_BUTTON_RIGHT : SDL_BUTTON_LEFT;
      ev.button.state = down ? SDL_PRESSED : SDL_RELEASED;
      ev.button.clicks = 1;
      ev.button.x = x;
      ev.button.y = y;
    }
    SDL_PushEvent(&ev);
    if (d.log != nullptr) {
      std::fprintf(d.log, "%9.1f script %s %d %d\n", InputDebugMs(),
                   step.action.c_str(), x, y);
    }
  }
}
#endif  // YAZE_USE_SDL3
 
void InputDebugLogFrame() {
  auto& d = GetInputDebug();
  if (d.log == nullptr) {
    return;
  }
  const ImGuiContext& g = *ImGui::GetCurrentContext();
  const ImGuiIO& io = g.IO;
  std::string popups;
  for (const ImGuiPopupData& p : g.OpenPopupStack) {
    char id[48];
    std::snprintf(id, sizeof(id), "(pending id=%08X parent=%08X f=%d)",
                  p.PopupId, p.OpenParentId, p.OpenFrameCount);
    popups += p.Window ? p.Window->Name : id;
    popups += "|";
  }
  char line[1024];
  std::snprintf(
      line, sizeof(line),
      "down=%d%d%d clk=%d%d rel=%d%d pos=%.0f,%.0f hovwin=%s hovid=%08X "
      "active=%08X(%s) nav=%s text=%d mods=0x%x focus=%d popups=[%s]",
      io.MouseDown[0], io.MouseDown[1], io.MouseDown[2], io.MouseClicked[0],
      io.MouseClicked[1], io.MouseReleased[0], io.MouseReleased[1],
      io.MousePos.x, io.MousePos.y,
      g.HoveredWindow ? g.HoveredWindow->Name : "-", g.HoveredIdPreviousFrame,
      g.ActiveId, g.ActiveIdWindow ? g.ActiveIdWindow->Name : "-",
      g.NavWindow ? g.NavWindow->Name : "-", io.WantTextInput ? 1 : 0,
      static_cast<unsigned>(io.KeyMods), io.AppFocusLost ? 0 : 1,
      popups.c_str());
  const bool edge = io.MouseClicked[0] || io.MouseClicked[1] ||
                    io.MouseReleased[0] || io.MouseReleased[1];
  if (edge || d.last_frame_line != line) {
    std::fprintf(d.log, "%9.1f frame=%d %s\n", InputDebugMs(), g.FrameCount,
                 line);
    std::fflush(d.log);
    d.last_frame_line = line;
  }
}
 
}  // namespace
 
absl::Status Controller::OnEntry(std::string filename) {
  // Create window backend using factory (auto-selects SDL2 or SDL3)
  auto backend_type = platform::WindowBackendFactory::GetDefaultType();
  auto renderer_type = gfx::RendererFactory::GetDefaultBackendType();
 
  const auto& app_config = Application::Instance().GetConfig();
 
  if (app_config.headless) {
    LOG_INFO("Controller", "Using Null Window Backend (Headless Mode)");
    backend_type = platform::WindowBackendType::Null;
    renderer_type = gfx::RendererBackendType::Null;
  }
 
#if defined(__APPLE__) && \
    (TARGET_OS_IPHONE == 1 || TARGET_IPHONE_SIMULATOR == 1)
  backend_type = platform::WindowBackendType::IOS;
  renderer_type = gfx::RendererBackendType::Metal;
#endif
 
  // A second OnEntry() replaces the backend. Drop the waker first so no
  // service thread can wake the backend that is about to be destroyed.
  util::UiThreadQueue::Get().SetWaker({});
  window_backend_ = platform::WindowBackendFactory::Create(backend_type);
  if (!window_backend_) {
    return absl::InternalError("Failed to create window backend");
  }
 
  platform::WindowConfig config;
  config.title = "Yet Another Zelda3 Editor";
  config.resizable = true;
  config.high_dpi =
      false;  // Disabled to match legacy behavior (SDL_WINDOW_RESIZABLE only)
 
  if (app_config.service_mode) {
    LOG_INFO("Controller", "Starting in Service Mode (Hidden Window)");
    config.hidden = true;
  }
 
  RETURN_IF_ERROR(window_backend_->Initialize(config));
 
  // From here on, service threads hand editor work to this thread through
  // the queue instead of running it on their own threads. Binding before the
  // rest of OnEntry means an early RPC waits for the first frame rather than
  // racing initialization. The waker lets a posted task cut the idle wait.
  auto& ui_queue = util::UiThreadQueue::Get();
  ui_queue.BindToCurrentThread();
  ui_queue.SetWaker(
      [backend = window_backend_.get()]() { backend->WakeEventLoop(); });
 
  // Create renderer via factory (auto-selects SDL2 or SDL3)
  renderer_ = gfx::RendererFactory::Create(renderer_type);
  if (!window_backend_->InitializeRenderer(renderer_.get())) {
    return absl::InternalError("Failed to initialize renderer");
  }
 
  // Initialize ImGui via backend (handles SDL2/SDL3 automatically)
  RETURN_IF_ERROR(window_backend_->InitializeImGui(renderer_.get()));
 
  // The test manager is linked at the controller/executable layer rather than
  // the platform window library. Initialize its engine here, after ImGui has a
  // context, so remote harness actions use the real engine. The dedicated GUI
  // test runner owns a separate engine and initializes it below its OnEntry().
#if defined(YAZE_ENABLE_IMGUI_TEST_ENGINE) && YAZE_ENABLE_IMGUI_TEST_ENGINE && \
    !defined(YAZE_GUI_TEST_TARGET)
  test::TestManager::Get().InitializeUITesting();
#endif
 
  // Initialize the graphics Arena with the renderer
  gfx::Arena::Get().Initialize(renderer_.get());
 
  // Set up audio for emulator (using backend's audio resources)
  auto audio_buffer = window_backend_->GetAudioBuffer();
  if (audio_buffer) {
    editor_manager_.emulator().set_audio_buffer(audio_buffer.get());
  }
  editor_manager_.emulator().set_audio_device_id(
      window_backend_->GetAudioDevice());
 
  editor_manager_.SetAssetLoadMode(
      Application::Instance().GetConfig().asset_load_mode);
 
  // Initialize editor manager with renderer
  editor_manager_.Initialize(renderer_.get(), filename);
 
  // imgui.ini loads on the first NewFrame; the layout section needs its
  // handler registered before then.
  if (auto* mgr = editor::ContentRegistry::Context::layout_manager()) {
    mgr->RegisterLayoutIniHandler();
  }
 
  active_ = true;
  return absl::OkStatus();
}
 
void Controller::SetStartupEditor(const std::string& editor_name,
                                  const std::string& panels) {
  // Process command-line flags for editor and panels
  // Example: --editor=Dungeon --open_panels="dungeon.room_list,Room 0"
  if (!editor_name.empty()) {
    editor_manager_.OpenEditorAndPanelsFromFlags(editor_name, panels);
  }
}
 
void Controller::OnInput() {
  if (!window_backend_)
    return;
 
  // Idle pacing. With nothing to animate and no input for a while, wait for
  // the next event instead of drawing at the display rate: 10 fps after
  // util::kMainLoopIdleAfter of quiet, 4 fps while the window is hidden or
  // minimized (see util::MainLoopEventWaitMs). Any
  // event (mouse move, key, window change) wakes the loop at once, and work
  // that needs frames (emulator, music, texture uploads, UI tests,
  // screenshots) keeps full rate. Queued UI-thread tasks also skip the wait;
  // tasks posted during the wait end it through WakeEventLoop().
  {
    bool busy = editor_manager_.WantsContinuousFrames() ||
                editor_control_queue_.pending();
    {
      std::lock_guard<std::mutex> lock(screenshot_mutex_);
      busy = busy || !screenshot_requests_.empty();
    }
#if defined(YAZE_ENABLE_IMGUI_TEST_ENGINE) && YAZE_ENABLE_IMGUI_TEST_ENGINE
    auto& tests = test::TestManager::Get();
    busy = busy || tests.IsTestRunning();
    // Harness RPCs queue engine tests that advance one frame at a time; a
    // task stays in the queue until it finishes.
    if (auto* engine = tests.GetUITestEngine()) {
      busy = busy || !ImGuiTestEngine_IsTestQueueEmpty(engine);
    }
#endif
    util::MainLoopIdleState idle;
    idle.busy = busy;
    idle.ui_tasks_pending = util::UiThreadQueue::Get().HasPendingTasks();
    idle.window_hidden = window_hidden_;
    idle.quiet_for = std::chrono::steady_clock::now() - last_event_time_;
    const int wait_ms = util::MainLoopEventWaitMs(idle);
    if (!idle.busy && !idle.ui_tasks_pending) {
      // Write batched log lines before going quiet, so they are on disk if
      // the app then crashes or is killed.
      util::LogManager::instance().Flush();
    }
    if (wait_ms > 0) {
      window_backend_->WaitForEvent(wait_ms);
    }
  }
 
  {
    auto& debug = GetInputDebug();
    if (!debug.started) {
      debug.started = true;
      debug.start = std::chrono::steady_clock::now();
    }
#ifndef YAZE_USE_SDL3
    if (!debug.script.empty() && ImGui::GetCurrentContext() != nullptr) {
      InputDebugRunScript();
    }
#endif
  }
 
  platform::WindowEvent event;
  while (window_backend_->PollEvent(event)) {
    // A wake event only ends the idle wait so OnLoad() drains the UI task
    // queue. It is not user activity: do not reset the idle timer or pass
    // it to the emulator.
    if (event.has_native_event && platform::IsWakeEvent(event.native_event)) {
      continue;
    }
#ifndef YAZE_USE_SDL3
    if (event.has_native_event) {
      InputDebugLogSdlEvent(event.native_event);
    }
#endif
    last_event_time_ = std::chrono::steady_clock::now();
    switch (event.type) {
      case platform::WindowEventType::Quit:
      case platform::WindowEventType::Close:
        // Native close requests must follow the same guarded quit path as the
        // menu and keyboard shortcut. EditorManager keeps the application
        // alive while the user resolves any unsaved-session prompt.
        editor_manager_.Quit();
        break;
 
      case platform::WindowEventType::Minimized:
      case platform::WindowEventType::Hidden:
        window_hidden_ = true;
        editor_manager_.HandleHostVisibilityChanged(false);
        break;
 
      case platform::WindowEventType::FocusLost:
        editor_manager_.HandleHostVisibilityChanged(false);
        break;
 
      case platform::WindowEventType::Restored:
      case platform::WindowEventType::Shown:
      case platform::WindowEventType::Exposed:
      case platform::WindowEventType::FocusGained:
        window_hidden_ = false;
        editor_manager_.HandleHostVisibilityChanged(true);
        break;
 
      default:
        // Other events are handled by ImGui via ProcessNativeEvent
        // which is called inside PollEvent
        break;
    }
 
    // Forward native SDL events to emulator input for event-based paths
    if (event.has_native_event) {
      editor_manager_.emulator().input_manager().ProcessEvent(
          static_cast<void*>(&event.native_event));
    }
  }
}
 
absl::StatusOr<std::string> Controller::RequestEditorControl(
    const std::string& json) {
  return editor_control_queue_.Submit(json);
}
 
absl::Status Controller::OnLoad() {
  if (!window_backend_) {
    return absl::InternalError("Window backend not initialized");
  }
 
  if (editor_manager_.quit() || !window_backend_->IsActive()) {
    active_ = false;
    // No more frames will drain the queue. Cancel waiting service calls now,
    // before Application::Shutdown() stops the gRPC server, which waits for
    // in-flight RPCs to return.
    util::UiThreadQueue::Get().Shutdown();
    return absl::OkStatus();
  }
 
  // Run work posted by gRPC and HTTP threads before the frame starts, so
  // the frame draws the state those tasks produced. Tasks must not call
  // ImGui frame functions: no frame is open yet.
  util::UiThreadQueue::Get().Drain();
 
  // Start new ImGui frame via backend (handles SDL2/SDL3 automatically)
  window_backend_->NewImGuiFrame();
  ImGui::NewFrame();
  // Include every application widget, including menus, in this frame.
  gui::WidgetIdRegistry::Instance().BeginFrame();
  InputDebugLogFrame();
  editor_control_queue_.ProcessOne([this](const std::string& request) {
    return editor_manager_.ExecuteEditorControl(request);
  });
 
  // Advance any in-progress theme color transitions
  gui::ThemeManager::Get().UpdateTransition();
 
  const ImGuiViewport* viewport = ImGui::GetMainViewport();
 
  // Calculate layout offsets for sidebars and status bar
  const float left_offset = editor_manager_.GetLeftLayoutOffset();
  const float right_offset = editor_manager_.GetRightLayoutOffset();
  float bottom_offset = editor_manager_.GetBottomLayoutOffset();
 
  float top_offset = 0.0f;
#if defined(__APPLE__) && \
    (TARGET_OS_IPHONE == 1 || TARGET_IPHONE_SIMULATOR == 1)
  // On iOS, inset the dockspace by the safe area so content doesn't render
  // behind the notch/Dynamic Island (top) or home indicator (bottom).
  {
    const auto safe = platform::ios::GetSafeAreaInsets();
    top_offset = std::max(safe.top, platform::ios::GetOverlayTopInset());
    bottom_offset += safe.bottom;
  }
#endif
 
  // Adjust dockspace position and size for sidebars and status bar
  ImVec2 dockspace_pos = viewport->WorkPos;
  ImVec2 dockspace_size = viewport->WorkSize;
 
  dockspace_pos.x += left_offset;
  dockspace_pos.y += top_offset;
  dockspace_size.x -= (left_offset + right_offset);
  dockspace_size.y -= (bottom_offset + top_offset);
 
  ImGui::SetNextWindowPos(dockspace_pos);
  ImGui::SetNextWindowSize(dockspace_size);
  ImGui::SetNextWindowViewport(viewport->ID);
 
  // Check if menu bar should be visible (WASM can hide it for clean UI)
  bool show_menu_bar = true;
  if (editor_manager_.ui_coordinator()) {
    show_menu_bar = editor_manager_.ui_coordinator()->IsMenuBarVisible();
  }
#if defined(__APPLE__) && \
    (TARGET_OS_IPHONE == 1 || TARGET_IPHONE_SIMULATOR == 1)
  show_menu_bar = false;
#endif
 
  ImGuiWindowFlags window_flags = ImGuiWindowFlags_NoDocking;
  if (show_menu_bar) {
    window_flags |= ImGuiWindowFlags_MenuBar;
  }
  window_flags |= ImGuiWindowFlags_NoTitleBar | ImGuiWindowFlags_NoCollapse |
                  ImGuiWindowFlags_NoResize | ImGuiWindowFlags_NoMove;
  window_flags |= ImGuiWindowFlags_NoBringToFrontOnFocus |
                  ImGuiWindowFlags_NoNavFocus | ImGuiWindowFlags_NoBackground;
 
  ImGui::PushStyleVar(ImGuiStyleVar_WindowRounding, 0.0f);
  ImGui::PushStyleVar(ImGuiStyleVar_WindowBorderSize, 0.0f);
  ImGui::PushStyleVar(ImGuiStyleVar_WindowPadding, ImVec2(0.0f, 0.0f));
  ImGui::Begin("DockSpaceWindow", nullptr, window_flags);
  ImGui::PopStyleVar(3);
 
  // Outer dockspace: the editor host fills its central node and pinned
  // panels share one node beside it. Its ID is a fixed hash (not salted by
  // the window ID stack) so every caller resolves the same node.
  const ImGuiID dockspace_id = editor::LayoutManager::OuterDockspaceId();
  auto* layout_manager = editor::ContentRegistry::Context::layout_manager();
  if (auto* mgr = layout_manager) {
    mgr->SetMainDockspaceId(dockspace_id);
    // Phase 8.2: one-shot startup reapply of the user's last applied
    // named layout. Idempotent — fires once per session on the first
    // frame the dockspace is bound and `last_applied_layout_name` is
    // set. Errors are logged inside the manager; we deliberately ignore
    // the return so a stale or removed layout doesn't block the editor
    // from coming up.
    (void)mgr->MaybeReapplyStartupLayout(
        editor::ContentRegistry::Context::user_settings());
  }
  // NoDockingSplit: panels cannot split the outer tree; they dock inside an
  // editor's dockspace or in the pin node.
  gui::DockSpaceRenderer::BeginEnhancedDockSpace(
      dockspace_id, ImVec2(0.0f, 0.0f),
      ImGuiDockNodeFlags_PassthruCentralNode |
          ImGuiDockNodeFlags_NoDockingSplit);
 
  if (show_menu_bar) {
    editor_manager_.DrawMainMenuBar();  // Draw the fixed menu bar at the top
  }
 
  gui::DockSpaceRenderer::EndEnhancedDockSpace();
 
  if (auto* bus = editor::ContentRegistry::Context::event_bus()) {
    bus->Publish(editor::FrameGuiBeginEvent::Create(ImGui::GetIO().DeltaTime));
  }
  ImGui::End();
 
  if (layout_manager) {
    layout_manager->DrawEditorHost();
  }
 
#if !defined(__APPLE__) || \
    (TARGET_OS_IPHONE != 1 && TARGET_IPHONE_SIMULATOR != 1)
  // Draw menu bar restore button when menu is hidden (WASM)
  if (!show_menu_bar && editor_manager_.ui_coordinator()) {
    editor_manager_.ui_coordinator()->DrawMenuBarRestoreButton();
  }
#endif
  absl::Status update_status = editor_manager_.Update();
  gui::WidgetIdRegistry::Instance().EndFrame();
  RETURN_IF_ERROR(update_status);
 
#if defined(__APPLE__) && \
    (TARGET_OS_IPHONE == 1 || TARGET_IPHONE_SIMULATOR == 1)
  {
    platform::ios::EditorStateSnapshot snap;
    auto* editor = editor_manager_.GetCurrentEditor();
    auto* rom = editor_manager_.GetCurrentRom();
    if (editor) {
      snap.can_undo = editor->undo_manager().CanUndo();
      snap.can_redo = editor->undo_manager().CanRedo();
      snap.editor_type =
          editor::kEditorNames[editor::EditorTypeIndex(editor->type())];
    }
    if (rom && rom->is_loaded()) {
      snap.can_save = true;
      snap.is_dirty = rom->dirty();
      snap.rom_title = rom->title();
    }
    platform::ios::PostEditorStateUpdate(snap);
  }
#endif
 
  return absl::OkStatus();
}
 
void Controller::DoRender() const {
  if (!window_backend_ || !renderer_)
    return;
 
  // Process pending texture commands.
  // During layout transitions, use a time-budgeted approach to reduce GPU
  // pressure and avoid Metal crashes from too many texture uploads per frame.
  // Every 30th frame during transitions, do a full queue pass to prevent starvation.
  {
    const auto sync_state = editor_manager_.GetUiSyncStateSnapshot();
    const bool in_transition = sync_state.layout_rebuild_pending ||
                               sync_state.pending_layout_actions > 0;
    if (in_transition && (sync_state.frame_id % 30 != 0)) {
      gfx::Arena::Get().ProcessTextureQueueWithBudget(renderer_.get(), 2.0f);
    } else {
      gfx::Arena::Get().ProcessTextureQueue(renderer_.get());
    }
  }
 
  if (Application::Instance().GetConfig().headless) {
    // In HEADLESS mode, we MUST still end the ImGui frame to satisfy assertions
    // even if we don't render to a window.
    ImGui::Render();
    gfx::Arena::Get().DrainRetiredBitmaps(renderer_.get());
    ProcessScreenshotRequests();
    return;
  }
 
  renderer_->Clear();
 
  // Render ImGui draw data and handle viewports via backend
  // This MUST be called even in headless mode to end the ImGui frame
  window_backend_->RenderImGui(renderer_.get());
 
  // Capture the rendered backbuffer before Present invalidates its contents.
  ProcessScreenshotRequests();
  renderer_->Present();
  gfx::Arena::Get().DrainRetiredBitmaps(renderer_.get());
 
#if defined(YAZE_ENABLE_IMGUI_TEST_ENGINE) && YAZE_ENABLE_IMGUI_TEST_ENGINE
  test::TestManager::Get().OnPostSwap();
#endif
 
  // Gentle cap for renderers without vsync (software fallback): if the frame
  // took under 7 ms (> ~144 fps), yield 1 ms. TimingManager is updated once
  // per frame by EditorManager; updating it here too halved its delta time
  // and made this check fire almost every frame.
  const auto frame_end = std::chrono::steady_clock::now();
  const auto frame_time = frame_end - last_frame_end_;
  last_frame_end_ = frame_end;
  if (frame_time < std::chrono::milliseconds(7)) {
#if TARGET_OS_IPHONE != 1
    SDL_Delay(1);
#endif
  }
}
 
void Controller::OnExit() {
#if defined(YAZE_ENABLE_IMGUI_TEST_ENGINE) && YAZE_ENABLE_IMGUI_TEST_ENGINE && \
    !defined(YAZE_GUI_TEST_TARGET)
  // Stop the test engine while its bound ImGui context is still alive.
  test::TestManager::Get().StopUITesting();
#endif
 
  if (renderer_) {
    // Retired handles contain no Bitmap pointers and are safe to destroy once
    // the final submitted frame is no longer using them.
    gfx::Arena::Get().DrainRetiredBitmaps(renderer_.get());
    gfx::Arena::Get().Initialize(nullptr);
    renderer_->Shutdown();
  }
  // Backstop for exits that skip the quit path in OnLoad(). Clearing the
  // waker waits for any wake in progress, so no service thread is inside
  // WakeEventLoop() when the backend shuts down.
  {
    auto& ui_queue = util::UiThreadQueue::Get();
    ui_queue.Shutdown();
    ui_queue.SetWaker({});
  }
  if (window_backend_) {
    window_backend_->Shutdown();
  }
 
#if defined(YAZE_ENABLE_IMGUI_TEST_ENGINE) && YAZE_ENABLE_IMGUI_TEST_ENGINE && \
    !defined(YAZE_GUI_TEST_TARGET)
  // The backend owns and destroys ImGui; release the engine context afterward.
  test::TestManager::Get().DestroyUITestingContext();
#endif
}
 
absl::Status Controller::LoadRomForTesting(const std::string& rom_path) {
  // Use EditorManager's OpenRomOrProject which handles the full initialization:
  // 1. Load ROM file into session
  // 2. ConfigureEditorDependencies()
  // 3. LoadAssetsForMode() - initializes all editors and loads graphics
  // 4. Updates UI state (hides welcome screen, etc.)
  auto previous_mode = editor_manager_.asset_load_mode();
  editor_manager_.SetAssetLoadMode(AssetLoadMode::kFull);
  auto status = editor_manager_.OpenRomOrProject(
      rom_path, editor::EditorManager::LoadOptionsPrompt::kNoPrompt);
  editor_manager_.SetAssetLoadMode(previous_mode);
  return status;
}
 
void Controller::ProcessScreenshotRequests() const {
#ifdef YAZE_WITH_GRPC
  std::queue<ScreenshotRequest> requests;
  {
    std::lock_guard<std::mutex> lock(screenshot_mutex_);
    requests.swap(screenshot_requests_);
  }
  while (!requests.empty()) {
    auto request = std::move(requests.front());
    requests.pop();
 
    absl::StatusOr<test::ScreenshotArtifact> result =
        absl::FailedPreconditionError(
            "Screenshots require a rendered GUI frame; use service mode "
            "instead of headless mode");
    if (!Application::Instance().GetConfig().headless) {
      result = request.window_title.empty()
                   ? test::CaptureHarnessScreenshot(request.preferred_path,
                                                    request.reveal_to_user,
                                                    request.format)
                   : test::CaptureWindowByName(
                         request.window_title, request.preferred_path,
                         request.reveal_to_user, request.format);
    }
    if (request.callback) {
      request.callback(std::move(result));
    }
  }
#endif
}
 
}  // namespace yaze