iwindow.h

Go to the documentation of this file.

// iwindow.h - Window Backend Abstraction Layer
// Provides interface for swapping window implementations (SDL2, SDL3)
 
#ifndef YAZE_APP_PLATFORM_IWINDOW_H_
#define YAZE_APP_PLATFORM_IWINDOW_H_
 
#include <cstdint>
#include <memory>
#include <string>
 
#include "absl/status/status.h"
#include "app/gfx/backend/irenderer.h"
#include "app/platform/sdl_compat.h"
 
// Forward declarations to avoid SDL header dependency in interface
struct SDL_Window;
 
namespace yaze {
namespace platform {
 
struct WindowConfig {
  std::string title = "Yet Another Zelda3 Editor";
  int width = 0;               // 0 means auto-detect from display
  int height = 0;              // 0 means auto-detect from display
  float display_scale = 0.8f;  // Percentage of display to use when auto-detect
  bool resizable = true;
  bool maximized = false;
  bool fullscreen = false;
  bool high_dpi =
      false;  // Disabled by default - causes issues on macOS Retina with SDL_Renderer
  bool hidden = false;  // Start window hidden (for service mode)
};
 
enum class WindowEventType {
  None,
  Close,
  Resize,
  Minimized,
  Maximized,
  Restored,
  Shown,
  Hidden,
  Exposed,
  FocusGained,
  FocusLost,
  KeyDown,
  KeyUp,
  MouseMotion,
  MouseButtonDown,
  MouseButtonUp,
  MouseWheel,
  Quit,
  DropFile
};
 
struct WindowEvent {
  WindowEventType type = WindowEventType::None;
 
  // Window resize data
  int window_width = 0;
  int window_height = 0;
 
  // Keyboard data
  int key_code = 0;
  int scan_code = 0;
  bool key_shift = false;
  bool key_ctrl = false;
  bool key_alt = false;
  bool key_super = false;
 
  // Mouse data
  float mouse_x = 0.0f;
  float mouse_y = 0.0f;
  int mouse_button = 0;
  float wheel_x = 0.0f;
  float wheel_y = 0.0f;
 
  // Drop file data
  std::string dropped_file;
 
  // Native event copy (SDL2/SDL3). Only valid when has_native_event is true.
  bool has_native_event = false;
  SDL_Event native_event{};
};
 
struct WindowStatus {
  bool is_active = true;
  bool is_minimized = false;
  bool is_maximized = false;
  bool is_fullscreen = false;
  bool is_focused = true;
  bool is_resizing = false;
  int width = 0;
  int height = 0;
};
 
class IWindowBackend {
 public:
  virtual ~IWindowBackend() = default;
 
  // =========================================================================
  // Lifecycle Management
  // =========================================================================
 
  virtual absl::Status Initialize(const WindowConfig& config) = 0;
 
  virtual absl::Status Shutdown() = 0;
 
  virtual bool IsInitialized() const = 0;
 
  // =========================================================================
  // Event Processing
  // =========================================================================
 
  virtual bool PollEvent(WindowEvent& out_event) = 0;
 
  virtual void ProcessNativeEvent(void* native_event) = 0;
 
  // =========================================================================
  // Window State
  // =========================================================================
 
  virtual WindowStatus GetStatus() const = 0;
 
  virtual bool IsActive() const = 0;
 
  virtual void SetActive(bool active) = 0;
 
  virtual void GetSize(int* width, int* height) const = 0;
 
  virtual void SetSize(int width, int height) = 0;
 
  virtual std::string GetTitle() const = 0;
 
  virtual void SetTitle(const std::string& title) = 0;
 
  virtual void ShowWindow() = 0;
 
  virtual void HideWindow() = 0;
 
  // =========================================================================
  // Renderer Integration
  // =========================================================================
 
  virtual bool InitializeRenderer(gfx::IRenderer* renderer) = 0;
 
  virtual SDL_Window* GetNativeWindow() = 0;
 
  // =========================================================================
  // ImGui Integration
  // =========================================================================
 
  virtual absl::Status InitializeImGui(gfx::IRenderer* renderer) = 0;
 
  virtual void ShutdownImGui() = 0;
 
  virtual void NewImGuiFrame() = 0;
 
  virtual void RenderImGui(gfx::IRenderer* renderer) = 0;
 
  // =========================================================================
  // Audio Support (Legacy compatibility)
  // =========================================================================
 
  virtual uint32_t GetAudioDevice() const = 0;
 
  virtual std::shared_ptr<int16_t> GetAudioBuffer() const = 0;
 
  // =========================================================================
  // Backend Information
  // =========================================================================
 
  virtual std::string GetBackendName() const = 0;
 
  virtual int GetSDLVersion() const = 0;
};
 
enum class WindowBackendType {
  SDL2,
  SDL3,
  GLFW,  // Reserved for future native multi-viewport backend
  IOS,
  Null,  // Headless/Server mode
  Auto   // Automatically select based on availability
};
 
class WindowBackendFactory {
 public:
  static std::unique_ptr<IWindowBackend> Create(WindowBackendType type);
 
  static WindowBackendType GetDefaultType();
 
  static bool IsAvailable(WindowBackendType type);
};
 
}  // namespace platform
}  // namespace yaze
 
#endif  // YAZE_APP_PLATFORM_IWINDOW_H_