sdl_compat.h

Go to the documentation of this file.

#ifndef YAZE_APP_PLATFORM_SDL_COMPAT_H_
#define YAZE_APP_PLATFORM_SDL_COMPAT_H_
 
#ifdef YAZE_USE_SDL3
#include <SDL3/SDL.h>
#include <SDL3/SDL_gamepad.h>
#else
#include <SDL.h>
#endif
 
namespace yaze {
namespace platform {
 
// ============================================================================
// Type Aliases
// ============================================================================
 
#ifdef YAZE_USE_SDL3
// SDL3 uses bool* for keyboard state
using KeyboardState = const bool*;
#else
// SDL2 uses Uint8* for keyboard state
using KeyboardState = const Uint8*;
#endif
 
// ============================================================================
// Event Type Constants
// ============================================================================
 
#ifdef YAZE_USE_SDL3
constexpr auto kEventKeyDown = SDL_EVENT_KEY_DOWN;
constexpr auto kEventKeyUp = SDL_EVENT_KEY_UP;
constexpr auto kEventMouseMotion = SDL_EVENT_MOUSE_MOTION;
constexpr auto kEventMouseButtonDown = SDL_EVENT_MOUSE_BUTTON_DOWN;
constexpr auto kEventMouseButtonUp = SDL_EVENT_MOUSE_BUTTON_UP;
constexpr auto kEventMouseWheel = SDL_EVENT_MOUSE_WHEEL;
constexpr auto kEventQuit = SDL_EVENT_QUIT;
constexpr auto kEventDropFile = SDL_EVENT_DROP_FILE;
constexpr auto kEventWindowCloseRequested = SDL_EVENT_WINDOW_CLOSE_REQUESTED;
constexpr auto kEventWindowResized = SDL_EVENT_WINDOW_RESIZED;
constexpr auto kEventGamepadAdded = SDL_EVENT_GAMEPAD_ADDED;
constexpr auto kEventGamepadRemoved = SDL_EVENT_GAMEPAD_REMOVED;
#else
constexpr auto kEventKeyDown = SDL_KEYDOWN;
constexpr auto kEventKeyUp = SDL_KEYUP;
constexpr auto kEventMouseMotion = SDL_MOUSEMOTION;
constexpr auto kEventMouseButtonDown = SDL_MOUSEBUTTONDOWN;
constexpr auto kEventMouseButtonUp = SDL_MOUSEBUTTONUP;
constexpr auto kEventMouseWheel = SDL_MOUSEWHEEL;
constexpr auto kEventQuit = SDL_QUIT;
constexpr auto kEventDropFile = SDL_DROPFILE;
// SDL2 uses SDL_WINDOWEVENT with sub-types, not individual events
// These are handled specially in window code
constexpr auto kEventWindowEvent = SDL_WINDOWEVENT;
constexpr auto kEventControllerDeviceAdded = SDL_CONTROLLERDEVICEADDED;
constexpr auto kEventControllerDeviceRemoved = SDL_CONTROLLERDEVICEREMOVED;
#endif
 
// ============================================================================
// Key Constants
// ============================================================================
 
#ifdef YAZE_USE_SDL3
#include <SDL3/SDL_keycode.h>
 
constexpr auto kKeyA = 'a';
constexpr auto kKeyB = 'b';
constexpr auto kKeyC = 'c';
constexpr auto kKeyD = 'd';
constexpr auto kKeyS = 's';
constexpr auto kKeyX = 'x';
constexpr auto kKeyY = 'y';
constexpr auto kKeyZ = 'z';
constexpr auto kKeyReturn = SDLK_RETURN;
constexpr auto kKeyRShift = SDLK_RSHIFT;
constexpr auto kKeyUp = SDLK_UP;
constexpr auto kKeyDown = SDLK_DOWN;
constexpr auto kKeyLeft = SDLK_LEFT;
constexpr auto kKeyRight = SDLK_RIGHT;
#else
constexpr auto kKeyA = SDLK_a;
constexpr auto kKeyB = SDLK_b;
constexpr auto kKeyC = SDLK_c;
constexpr auto kKeyD = SDLK_d;
constexpr auto kKeyS = SDLK_s;
constexpr auto kKeyX = SDLK_x;
constexpr auto kKeyY = SDLK_y;
constexpr auto kKeyZ = SDLK_z;
constexpr auto kKeyReturn = SDLK_RETURN;
constexpr auto kKeyRShift = SDLK_RSHIFT;
constexpr auto kKeyUp = SDLK_UP;
constexpr auto kKeyDown = SDLK_DOWN;
constexpr auto kKeyLeft = SDLK_LEFT;
constexpr auto kKeyRight = SDLK_RIGHT;
#endif
 
// ============================================================================
// Keyboard Helpers
// ============================================================================
 
inline SDL_Keycode GetKeyFromEvent(const SDL_Event& event) {
#ifdef YAZE_USE_SDL3
  return event.key.key;
#else
  return event.key.keysym.sym;
#endif
}
 
inline SDL_Scancode GetScancodeFromKey(SDL_Keycode key) {
#ifdef YAZE_USE_SDL3
  return SDL_GetScancodeFromKey(key, nullptr);
#else
  return SDL_GetScancodeFromKey(key);
#endif
}
 
inline bool IsKeyPressed(KeyboardState state, SDL_Scancode scancode) {
#ifdef YAZE_USE_SDL3
  // SDL3 returns bool*
  return state[scancode];
#else
  // SDL2 returns Uint8*, non-zero means pressed
  return state[scancode] != 0;
#endif
}
 
// ============================================================================
// Gamepad/Controller Helpers
// ============================================================================
 
#ifdef YAZE_USE_SDL3
// SDL3 uses SDL_Gamepad instead of SDL_GameController
using GamepadHandle = SDL_Gamepad*;
 
inline GamepadHandle OpenGamepad(int index) {
  SDL_JoystickID* joysticks = SDL_GetGamepads(nullptr);
  if (joysticks && index < 4) {
    SDL_JoystickID id = joysticks[index];
    SDL_free(joysticks);
    return SDL_OpenGamepad(id);
  }
  if (joysticks)
    SDL_free(joysticks);
  return nullptr;
}
 
inline void CloseGamepad(GamepadHandle gamepad) {
  if (gamepad)
    SDL_CloseGamepad(gamepad);
}
 
inline bool GetGamepadButton(GamepadHandle gamepad, SDL_GamepadButton button) {
  return SDL_GetGamepadButton(gamepad, button);
}
 
inline int16_t GetGamepadAxis(GamepadHandle gamepad, SDL_GamepadAxis axis) {
  return SDL_GetGamepadAxis(gamepad, axis);
}
 
inline bool IsGamepadConnected(int index) {
  int count = 0;
  SDL_JoystickID* joysticks = SDL_GetGamepads(&count);
  if (joysticks) {
    SDL_free(joysticks);
  }
  return index < count;
}
#else
// SDL2 uses SDL_GameController
using GamepadHandle = SDL_GameController*;
 
inline GamepadHandle OpenGamepad(int index) {
  if (SDL_IsGameController(index)) {
    return SDL_GameControllerOpen(index);
  }
  return nullptr;
}
 
inline void CloseGamepad(GamepadHandle gamepad) {
  if (gamepad)
    SDL_GameControllerClose(gamepad);
}
 
inline bool GetGamepadButton(GamepadHandle gamepad,
                             SDL_GameControllerButton button) {
  return SDL_GameControllerGetButton(gamepad, button) != 0;
}
 
inline int16_t GetGamepadAxis(GamepadHandle gamepad,
                              SDL_GameControllerAxis axis) {
  return SDL_GameControllerGetAxis(gamepad, axis);
}
 
inline bool IsGamepadConnected(int index) {
  return SDL_IsGameController(index);
}
#endif
 
// ============================================================================
// Button/Axis Type Aliases
// ============================================================================
 
#ifdef YAZE_USE_SDL3
using GamepadButton = SDL_GamepadButton;
using GamepadAxis = SDL_GamepadAxis;
 
constexpr auto kGamepadButtonA = SDL_GAMEPAD_BUTTON_SOUTH;
constexpr auto kGamepadButtonB = SDL_GAMEPAD_BUTTON_EAST;
constexpr auto kGamepadButtonX = SDL_GAMEPAD_BUTTON_WEST;
constexpr auto kGamepadButtonY = SDL_GAMEPAD_BUTTON_NORTH;
constexpr auto kGamepadButtonBack = SDL_GAMEPAD_BUTTON_BACK;
constexpr auto kGamepadButtonStart = SDL_GAMEPAD_BUTTON_START;
constexpr auto kGamepadButtonLeftShoulder = SDL_GAMEPAD_BUTTON_LEFT_SHOULDER;
constexpr auto kGamepadButtonRightShoulder = SDL_GAMEPAD_BUTTON_RIGHT_SHOULDER;
constexpr auto kGamepadButtonDpadUp = SDL_GAMEPAD_BUTTON_DPAD_UP;
constexpr auto kGamepadButtonDpadDown = SDL_GAMEPAD_BUTTON_DPAD_DOWN;
constexpr auto kGamepadButtonDpadLeft = SDL_GAMEPAD_BUTTON_DPAD_LEFT;
constexpr auto kGamepadButtonDpadRight = SDL_GAMEPAD_BUTTON_DPAD_RIGHT;
 
constexpr auto kGamepadAxisLeftX = SDL_GAMEPAD_AXIS_LEFTX;
constexpr auto kGamepadAxisLeftY = SDL_GAMEPAD_AXIS_LEFTY;
#else
using GamepadButton = SDL_GameControllerButton;
using GamepadAxis = SDL_GameControllerAxis;
 
constexpr auto kGamepadButtonA = SDL_CONTROLLER_BUTTON_A;
constexpr auto kGamepadButtonB = SDL_CONTROLLER_BUTTON_B;
constexpr auto kGamepadButtonX = SDL_CONTROLLER_BUTTON_X;
constexpr auto kGamepadButtonY = SDL_CONTROLLER_BUTTON_Y;
constexpr auto kGamepadButtonBack = SDL_CONTROLLER_BUTTON_BACK;
constexpr auto kGamepadButtonStart = SDL_CONTROLLER_BUTTON_START;
constexpr auto kGamepadButtonLeftShoulder = SDL_CONTROLLER_BUTTON_LEFTSHOULDER;
constexpr auto kGamepadButtonRightShoulder =
    SDL_CONTROLLER_BUTTON_RIGHTSHOULDER;
constexpr auto kGamepadButtonDpadUp = SDL_CONTROLLER_BUTTON_DPAD_UP;
constexpr auto kGamepadButtonDpadDown = SDL_CONTROLLER_BUTTON_DPAD_DOWN;
constexpr auto kGamepadButtonDpadLeft = SDL_CONTROLLER_BUTTON_DPAD_LEFT;
constexpr auto kGamepadButtonDpadRight = SDL_CONTROLLER_BUTTON_DPAD_RIGHT;
 
constexpr auto kGamepadAxisLeftX = SDL_CONTROLLER_AXIS_LEFTX;
constexpr auto kGamepadAxisLeftY = SDL_CONTROLLER_AXIS_LEFTY;
#endif
 
// ============================================================================
// Renderer Helpers
// ============================================================================
 
inline SDL_Renderer* CreateRenderer(SDL_Window* window) {
#ifdef YAZE_USE_SDL3
  return SDL_CreateRenderer(window, nullptr);
#else
  SDL_Renderer* renderer =
      SDL_CreateRenderer(window, -1, SDL_RENDERER_ACCELERATED);
  if (renderer == nullptr) {
    // No working GL acceleration (VM, remote/forwarded X, broken Mesa).
    // Fall back to software rendering so the app can still start.
    SDL_LogWarn(SDL_LOG_CATEGORY_RENDER,
                "Accelerated renderer unavailable (%s); "
                "falling back to software rendering",
                SDL_GetError());
    renderer = SDL_CreateRenderer(window, -1, SDL_RENDERER_SOFTWARE);
  }
  return renderer;
#endif
}
 
inline void SetRenderVSync(SDL_Renderer* renderer, int interval) {
#ifdef YAZE_USE_SDL3
  SDL_SetRenderVSync(renderer, interval);
#else
  // SDL2 sets vsync at creation time, this is a no-op
  (void)renderer;
  (void)interval;
#endif
}
 
inline bool RenderTexture(SDL_Renderer* renderer, SDL_Texture* texture,
                          const SDL_Rect* srcrect, const SDL_Rect* dstrect) {
#ifdef YAZE_USE_SDL3
  SDL_FRect src_frect, dst_frect;
  SDL_FRect* src_ptr = nullptr;
  SDL_FRect* dst_ptr = nullptr;
 
  if (srcrect) {
    src_frect.x = static_cast<float>(srcrect->x);
    src_frect.y = static_cast<float>(srcrect->y);
    src_frect.w = static_cast<float>(srcrect->w);
    src_frect.h = static_cast<float>(srcrect->h);
    src_ptr = &src_frect;
  }
 
  if (dstrect) {
    dst_frect.x = static_cast<float>(dstrect->x);
    dst_frect.y = static_cast<float>(dstrect->y);
    dst_frect.w = static_cast<float>(dstrect->w);
    dst_frect.h = static_cast<float>(dstrect->h);
    dst_ptr = &dst_frect;
  }
 
  return SDL_RenderTexture(renderer, texture, src_ptr, dst_ptr);
#else
  return SDL_RenderCopy(renderer, texture, srcrect, dstrect) == 0;
#endif
}
 
// ============================================================================
// Surface Helpers
// ============================================================================
 
inline void FreeSurface(SDL_Surface* surface) {
  if (!surface)
    return;
#ifdef YAZE_USE_SDL3
  SDL_DestroySurface(surface);
#else
  SDL_FreeSurface(surface);
#endif
}
 
inline SDL_Surface* ConvertSurfaceFormat(SDL_Surface* surface, uint32_t format,
                                         uint32_t flags = 0) {
  if (!surface)
    return nullptr;
#ifdef YAZE_USE_SDL3
  (void)flags;  // SDL3 removed flags parameter
  return SDL_ConvertSurface(surface, static_cast<SDL_PixelFormat>(format));
#else
  return SDL_ConvertSurfaceFormat(surface, format, flags);
#endif
}
 
inline SDL_Palette* GetSurfacePalette(SDL_Surface* surface) {
  if (!surface)
    return nullptr;
#ifdef YAZE_USE_SDL3
  return SDL_GetSurfacePalette(surface);
#else
  return surface->format ? surface->format->palette : nullptr;
#endif
}
 
inline Uint32 GetSurfaceFormat(SDL_Surface* surface) {
#ifdef YAZE_USE_SDL3
  return surface ? static_cast<Uint32>(surface->format)
                 : SDL_PIXELFORMAT_UNKNOWN;
#else
  return (surface && surface->format) ? surface->format->format
                                      : SDL_PIXELFORMAT_UNKNOWN;
#endif
}
 
inline Uint32 MapRGB(SDL_Surface* surface, Uint8 r, Uint8 g, Uint8 b) {
  if (!surface)
    return 0;
#ifdef YAZE_USE_SDL3
  const SDL_PixelFormatDetails* details =
      SDL_GetPixelFormatDetails(surface->format);
  if (!details)
    return 0;
  SDL_Palette* palette = SDL_GetSurfacePalette(surface);
  return SDL_MapRGB(details, palette, r, g, b);
#else
  return SDL_MapRGB(surface->format, r, g, b);
#endif
}
 
inline SDL_Surface* CreateSurface(int width, int height, int depth,
                                  uint32_t format) {
#ifdef YAZE_USE_SDL3
  (void)depth;  // SDL3 infers depth from format
  return SDL_CreateSurface(width, height, static_cast<SDL_PixelFormat>(format));
#else
  return SDL_CreateRGBSurfaceWithFormat(0, width, height, depth, format);
#endif
}
 
inline int GetSurfaceBitsPerPixel(SDL_Surface* surface) {
  if (!surface)
    return 0;
#ifdef YAZE_USE_SDL3
  const SDL_PixelFormatDetails* details =
      SDL_GetPixelFormatDetails(surface->format);
  return details ? details->bits_per_pixel : 0;
#else
  return surface->format ? surface->format->BitsPerPixel : 0;
#endif
}
 
inline bool EnsureSurfacePalette256(SDL_Surface* surface) {
  if (!surface)
    return false;
 
  SDL_Palette* existing = GetSurfacePalette(surface);
  if (existing && existing->ncolors >= 256) {
    return true;  // Already has proper palette
  }
 
  // Check if this is an indexed format that needs a palette
  int bpp = GetSurfaceBitsPerPixel(surface);
  if (bpp != 8) {
    return true;  // Not an indexed format, no palette needed
  }
 
  // Create a new 256-color palette (SDL2: SDL_AllocPalette, SDL3: SDL_CreatePalette)
#ifdef YAZE_USE_SDL3
  SDL_Palette* new_palette = SDL_CreatePalette(256);
#else
  SDL_Palette* new_palette = SDL_AllocPalette(256);
#endif
  if (!new_palette) {
    SDL_Log("Warning: Failed to create 256-color palette: %s", SDL_GetError());
    return false;
  }
 
  // Initialize with grayscale as a safe default
  SDL_Color colors[256];
  for (int i = 0; i < 256; i++) {
    colors[i].r = colors[i].g = colors[i].b = static_cast<Uint8>(i);
    colors[i].a = 255;
  }
  SDL_SetPaletteColors(new_palette, colors, 0, 256);
 
  // Attach to surface
  if (SDL_SetSurfacePalette(surface, new_palette) != 0) {
    SDL_Log("Warning: Failed to set surface palette: %s", SDL_GetError());
#ifdef YAZE_USE_SDL3
    SDL_DestroyPalette(new_palette);
#else
    SDL_FreePalette(new_palette);
#endif
    return false;
  }
 
  return true;
}
 
inline int GetSurfaceBytesPerPixel(SDL_Surface* surface) {
  if (!surface)
    return 0;
#ifdef YAZE_USE_SDL3
  const SDL_PixelFormatDetails* details =
      SDL_GetPixelFormatDetails(surface->format);
  return details ? details->bytes_per_pixel : 0;
#else
  return surface->format ? surface->format->BytesPerPixel : 0;
#endif
}
 
// ============================================================================
// Window Event Compatibility Macros
// These macros allow code to handle window events consistently across SDL2/SDL3
// ============================================================================
 
#ifdef YAZE_USE_SDL3
 
// SDL3 has individual window events at the top level
#define YAZE_SDL_QUIT SDL_EVENT_QUIT
#define YAZE_SDL_WINDOWEVENT 0  // Placeholder - SDL3 has no combined event
 
// SDL3 window events are individual event types
#define YAZE_SDL_WINDOW_CLOSE SDL_EVENT_WINDOW_CLOSE_REQUESTED
#define YAZE_SDL_WINDOW_RESIZED SDL_EVENT_WINDOW_RESIZED
#define YAZE_SDL_WINDOW_SIZE_CHANGED SDL_EVENT_WINDOW_PIXEL_SIZE_CHANGED
#define YAZE_SDL_WINDOW_MINIMIZED SDL_EVENT_WINDOW_MINIMIZED
#define YAZE_SDL_WINDOW_MAXIMIZED SDL_EVENT_WINDOW_MAXIMIZED
#define YAZE_SDL_WINDOW_RESTORED SDL_EVENT_WINDOW_RESTORED
#define YAZE_SDL_WINDOW_SHOWN SDL_EVENT_WINDOW_SHOWN
#define YAZE_SDL_WINDOW_HIDDEN SDL_EVENT_WINDOW_HIDDEN
#define YAZE_SDL_WINDOW_EXPOSED SDL_EVENT_WINDOW_EXPOSED
#define YAZE_SDL_WINDOW_FOCUS_GAINED SDL_EVENT_WINDOW_FOCUS_GAINED
#define YAZE_SDL_WINDOW_FOCUS_LOST SDL_EVENT_WINDOW_FOCUS_LOST
 
// SDL3 has no nested window events
#define YAZE_SDL_HAS_INDIVIDUAL_WINDOW_EVENTS 1
 
#else  // SDL2
 
// SDL2 event types
#define YAZE_SDL_QUIT SDL_QUIT
#define YAZE_SDL_WINDOWEVENT SDL_WINDOWEVENT
 
// SDL2 window events are nested under SDL_WINDOWEVENT
#define YAZE_SDL_WINDOW_CLOSE SDL_WINDOWEVENT_CLOSE
#define YAZE_SDL_WINDOW_RESIZED SDL_WINDOWEVENT_RESIZED
#define YAZE_SDL_WINDOW_SIZE_CHANGED SDL_WINDOWEVENT_SIZE_CHANGED
#define YAZE_SDL_WINDOW_MINIMIZED SDL_WINDOWEVENT_MINIMIZED
#define YAZE_SDL_WINDOW_MAXIMIZED SDL_WINDOWEVENT_MAXIMIZED
#define YAZE_SDL_WINDOW_RESTORED SDL_WINDOWEVENT_RESTORED
#define YAZE_SDL_WINDOW_SHOWN SDL_WINDOWEVENT_SHOWN
#define YAZE_SDL_WINDOW_HIDDEN SDL_WINDOWEVENT_HIDDEN
#define YAZE_SDL_WINDOW_EXPOSED SDL_WINDOWEVENT_EXPOSED
#define YAZE_SDL_WINDOW_FOCUS_GAINED SDL_WINDOWEVENT_FOCUS_GAINED
#define YAZE_SDL_WINDOW_FOCUS_LOST SDL_WINDOWEVENT_FOCUS_LOST
 
// SDL2 uses nested window events
#define YAZE_SDL_HAS_INDIVIDUAL_WINDOW_EVENTS 0
 
#endif  // YAZE_USE_SDL3
 
// ============================================================================
// Window Event Helper Functions
// ============================================================================
 
inline bool IsWindowCloseEvent(const SDL_Event& event) {
#ifdef YAZE_USE_SDL3
  return event.type == SDL_EVENT_WINDOW_CLOSE_REQUESTED;
#else
  return event.type == SDL_WINDOWEVENT &&
         event.window.event == SDL_WINDOWEVENT_CLOSE;
#endif
}
 
inline bool IsWindowResizeEvent(const SDL_Event& event) {
#ifdef YAZE_USE_SDL3
  return event.type == SDL_EVENT_WINDOW_RESIZED ||
         event.type == SDL_EVENT_WINDOW_PIXEL_SIZE_CHANGED;
#else
  return event.type == SDL_WINDOWEVENT &&
         (event.window.event == SDL_WINDOWEVENT_RESIZED ||
          event.window.event == SDL_WINDOWEVENT_SIZE_CHANGED);
#endif
}
 
inline bool IsWindowMinimizedEvent(const SDL_Event& event) {
#ifdef YAZE_USE_SDL3
  return event.type == SDL_EVENT_WINDOW_MINIMIZED;
#else
  return event.type == SDL_WINDOWEVENT &&
         event.window.event == SDL_WINDOWEVENT_MINIMIZED;
#endif
}
 
inline bool IsWindowRestoredEvent(const SDL_Event& event) {
#ifdef YAZE_USE_SDL3
  return event.type == SDL_EVENT_WINDOW_RESTORED;
#else
  return event.type == SDL_WINDOWEVENT &&
         event.window.event == SDL_WINDOWEVENT_RESTORED;
#endif
}
 
inline int GetWindowEventWidth(const SDL_Event& event) {
  return event.window.data1;
}
 
inline int GetWindowEventHeight(const SDL_Event& event) {
  return event.window.data2;
}
 
// ============================================================================
// Initialization Helpers
// ============================================================================
 
inline bool InitSucceeded(int result) {
#ifdef YAZE_USE_SDL3
  // SDL3 returns bool (non-zero for success)
  return result != 0;
#else
  // SDL2 returns 0 for success
  return result == 0;
#endif
}
 
inline uint32_t GetDefaultInitFlags() {
#ifdef YAZE_USE_SDL3
  return SDL_INIT_VIDEO | SDL_INIT_AUDIO | SDL_INIT_EVENTS;
#else
  return SDL_INIT_VIDEO | SDL_INIT_AUDIO | SDL_INIT_TIMER | SDL_INIT_EVENTS;
#endif
}
 
// ============================================================================
// Surface Helpers
// ============================================================================
 
inline SDL_Surface* CreateRGBSurface(Uint32 flags, int width, int height,
                                     int depth, Uint32 Rmask, Uint32 Gmask,
                                     Uint32 Bmask, Uint32 Amask) {
#ifdef YAZE_USE_SDL3
  // SDL3 uses SDL_CreateSurface with pixel format
  return SDL_CreateSurface(
      width, height,
      SDL_GetPixelFormatForMasks(depth, Rmask, Gmask, Bmask, Amask));
#else
  return SDL_CreateRGBSurface(flags, width, height, depth, Rmask, Gmask, Bmask,
                              Amask);
#endif
}
 
inline void DestroySurface(SDL_Surface* surface) {
#ifdef YAZE_USE_SDL3
  SDL_DestroySurface(surface);
#else
  SDL_FreeSurface(surface);
#endif
}
 
// ============================================================================
// Renderer Helpers
// ============================================================================
 
inline int GetRendererOutputSize(SDL_Renderer* renderer, int* w, int* h) {
#ifdef YAZE_USE_SDL3
  return SDL_GetCurrentRenderOutputSize(renderer, w, h);
#else
  return SDL_GetRendererOutputSize(renderer, w, h);
#endif
}
 
inline SDL_Surface* ReadPixelsToSurface(SDL_Renderer* renderer, int width,
                                        int height, const SDL_Rect* rect) {
#ifdef YAZE_USE_SDL3
  return SDL_RenderReadPixels(renderer, rect);
#else
  // Create surface to read into (ARGB8888 to match typical screenshot needs)
  SDL_Surface* surface = SDL_CreateRGBSurface(
      0, width, height, 32, 0x00FF0000, 0x0000FF00, 0x000000FF, 0xFF000000);
  if (!surface)
    return nullptr;
 
  if (SDL_RenderReadPixels(renderer, rect, SDL_PIXELFORMAT_ARGB8888,
                           surface->pixels, surface->pitch) != 0) {
    SDL_FreeSurface(surface);
    return nullptr;
  }
  return surface;
#endif
}
 
inline SDL_Surface* LoadBMP(const char* file) {
#ifdef YAZE_USE_SDL3
  return SDL_LoadBMP(file);
#else
  return SDL_LoadBMP(file);
#endif
}
 
}  // namespace platform
}  // namespace yaze
 
#endif  // YAZE_APP_PLATFORM_SDL_COMPAT_H_