controller.h

Go to the documentation of this file.

#ifndef YAZE_APP_CORE_CONTROLLER_H
#define YAZE_APP_CORE_CONTROLLER_H
 
#include "app/platform/sdl_compat.h"
 
#include <chrono>
#include <memory>
#include <mutex>
#include <queue>
#include <utility>
 
#include "absl/status/status.h"
#include "app/editor/editor_manager.h"
#include "app/gfx/backend/irenderer.h"
#include "app/platform/iwindow.h"
#include "app/service/editor_control_queue.h"
#include "app/service/screenshot_utils.h"
#include "rom/rom.h"
 
int main(int argc, char** argv);
 
namespace yaze {
 
class CanvasAutomationServiceImpl;
 
namespace test {
struct ScreenshotArtifact;
}
 
class Controller {
 public:
  struct ScreenshotRequest {
    std::string preferred_path;
    std::string window_title;
    test::ScreenshotFormat format = test::ScreenshotFormat::kAuto;
    bool reveal_to_user = false;
    std::function<void(absl::StatusOr<test::ScreenshotArtifact>)> callback;
  };
 
  bool IsActive() const { return active_; }
  absl::Status OnEntry(std::string filename = "");
  void OnInput();
  absl::Status OnLoad();
  void DoRender() const;
  void OnExit();
 
  // Defer a screenshot capture to the next render frame (thread-safe)
  void RequestScreenshot(const ScreenshotRequest& request);
 
  // HTTP worker entry point; all editor work runs on the main frame thread.
  absl::StatusOr<std::string> RequestEditorControl(const std::string& request);
 
  // Set startup editor and cards from command-line flags
  void SetStartupEditor(const std::string& editor_name,
                        const std::string& cards);
 
  // Window visibility control (for service mode)
  void ShowWindow() {
    if (window_backend_)
      window_backend_->ShowWindow();
  }
  void HideWindow() {
    if (window_backend_)
      window_backend_->HideWindow();
  }
 
  auto window() -> SDL_Window* {
    return window_backend_ ? window_backend_->GetNativeWindow() : nullptr;
  }
  void set_active(bool active) { active_ = active; }
  auto active() const { return active_; }
  auto overworld() -> yaze::zelda3::Overworld* {
    return editor_manager_.overworld();
  }
  auto GetCurrentRom() -> Rom* { return editor_manager_.GetCurrentRom(); }
  auto renderer() -> gfx::IRenderer* { return renderer_.get(); }
 
  // Test-friendly accessors for GUI testing with ImGuiTestEngine
  editor::EditorManager* editor_manager() { return &editor_manager_; }
 
  // Window backend accessor
  platform::IWindowBackend* window_backend() { return window_backend_.get(); }
 
  // Dependency-injection seam for focused controller event tests.
  void SetWindowBackendForTesting(
      std::unique_ptr<platform::IWindowBackend> window_backend) {
    window_backend_ = std::move(window_backend);
  }
 
  // Load a ROM file and initialize all editors for testing
  // This performs the full initialization flow including LoadAssets()
  absl::Status LoadRomForTesting(const std::string& rom_path);
 
#ifdef YAZE_WITH_GRPC
  void SetCanvasAutomationService(CanvasAutomationServiceImpl* service) {
    editor_manager_.SetCanvasAutomationService(service);
  }
#endif
 
 private:
  friend int ::main(int argc, char** argv);
 
  bool active_ = false;
  // Idle pacing (see Controller::OnInput): time of the last window event,
  // whether the window is hidden, and the end of the previous frame.
  std::chrono::steady_clock::time_point last_event_time_ =
      std::chrono::steady_clock::now();
  bool window_hidden_ = false;
  // Written by DoRender() const.
  mutable std::chrono::steady_clock::time_point last_frame_end_ =
      std::chrono::steady_clock::now();
  std::unique_ptr<platform::IWindowBackend> window_backend_;
  editor::EditorManager editor_manager_;
  std::unique_ptr<gfx::IRenderer> renderer_;
 
  // Thread-safe screenshot queue
  mutable std::mutex screenshot_mutex_;
  mutable std::queue<ScreenshotRequest> screenshot_requests_;
 
  app::EditorControlQueue editor_control_queue_;
 
  void ProcessScreenshotRequests() const;
};
 
}  // namespace yaze
 
#endif  // YAZE_APP_CORE_CONTROLLER_H