From 24fec13ac19a7ae1c885caf70f9dbddd49bf4a9f Mon Sep 17 00:00:00 2001 From: Sam Lantinga Date: Fri, 27 Jan 2023 10:46:51 -0800 Subject: [PATCH] Add full high DPI information to SDL_DisplayMode SDL_DisplayMode now includes the pixel size, the screen size and the relationship between the two. For example, a 4K display at 200% scale could have a pixel size of 3840x2160, a screen size of 1920x1080, and a display scale of 2.0. --- docs/README-migration.md | 2 + include/SDL3/SDL_video.h | 8 +- src/core/winrt/SDL_winrtapp_direct3d.cpp | 12 +- src/test/SDL_test_common.c | 10 +- src/video/SDL_video.c | 212 ++++++++++++--------- src/video/android/SDL_androidvideo.c | 36 ++-- src/video/cocoa/SDL_cocoamodes.m | 29 +-- src/video/dummy/SDL_nullvideo.c | 4 +- src/video/emscripten/SDL_emscriptenvideo.c | 3 +- src/video/haiku/SDL_bmodes.cc | 40 ++-- src/video/kmsdrm/SDL_kmsdrmvideo.c | 24 +-- src/video/n3ds/SDL_n3dsvideo.c | 8 +- src/video/ngage/SDL_ngagevideo.cpp | 4 +- src/video/offscreen/SDL_offscreenvideo.c | 4 +- src/video/ps2/SDL_ps2video.c | 20 +- src/video/psp/SDL_pspvideo.c | 25 ++- src/video/raspberry/SDL_rpivideo.c | 16 +- src/video/riscos/SDL_riscosmodes.c | 4 +- src/video/uikit/SDL_uikitmodes.m | 34 ++-- src/video/uikit/SDL_uikitwindow.m | 2 +- src/video/vita/SDL_vitavideo.c | 26 ++- src/video/vivante/SDL_vivantevideo.c | 18 +- src/video/wayland/SDL_waylandvideo.c | 34 ++-- src/video/windows/SDL_windowsmodes.c | 10 +- src/video/windows/SDL_windowsvideo.c | 17 +- src/video/winrt/SDL_winrtvideo.cpp | 38 ++-- src/video/x11/SDL_x11messagebox.c | 4 +- src/video/x11/SDL_x11modes.c | 38 ++-- test/testautomation_video.c | 27 +-- test/testdisplayinfo.c | 4 +- test/testwm.c | 2 +- 31 files changed, 370 insertions(+), 345 deletions(-) diff --git a/docs/README-migration.md b/docs/README-migration.md index 65d2a8870..723a0cda5 100644 --- a/docs/README-migration.md +++ b/docs/README-migration.md @@ -954,6 +954,8 @@ The SDL_WINDOW_SHOWN flag has been removed. Windows are shown by default and can The SDL_WINDOW_ALLOW_HIGHDPI flag has been removed. Windows are automatically high DPI aware and their coordinates are in screen space, which may differ from physical pixels on displays using display scaling. +SDL_DisplayMode now includes the pixel size, the screen size and the relationship between the two. For example, a 4K display at 200% scale could have a pixel size of 3840x2160, a screen size of 1920x1080, and a display scale of 2.0. + The refresh rate in SDL_DisplayMode is now a float. SDL_SetWindowBrightness and SDL_SetWindowGammaRamp have been removed from the API, because they interact poorly with modern operating systems and aren't able to limit their effects to the SDL window. diff --git a/include/SDL3/SDL_video.h b/include/SDL3/SDL_video.h index ba71957f4..7d7066b99 100644 --- a/include/SDL3/SDL_video.h +++ b/include/SDL3/SDL_video.h @@ -56,9 +56,11 @@ typedef Uint32 SDL_WindowID; typedef struct { Uint32 format; /**< pixel format */ - int w; /**< width in pixels */ - int h; /**< height in pixels */ - float display_scale; /**< scale converting screen coordinates to pixels (e.g. a 3840x2160 mode with 1.5 scale would have a screen size of 2560x1440) */ + int pixel_w; /**< width in pixels (used for creating back buffers) */ + int pixel_h; /**< height in pixels (used for creating back buffers) */ + int screen_w; /**< width in screen coordinates (used for creating windows) */ + int screen_h; /**< height in screen coordinates (used for creating windows) */ + float display_scale; /**< scale converting screen coordinates to pixels (e.g. a 2560x1440 screen size mode with 1.5 scale would have 3840x2160 pixels) */ float refresh_rate; /**< refresh rate (or zero for unspecified) */ void *driverdata; /**< driver-specific data, initialize to 0 */ } SDL_DisplayMode; diff --git a/src/core/winrt/SDL_winrtapp_direct3d.cpp b/src/core/winrt/SDL_winrtapp_direct3d.cpp index fd728fc8b..01d3a8afa 100644 --- a/src/core/winrt/SDL_winrtapp_direct3d.cpp +++ b/src/core/winrt/SDL_winrtapp_direct3d.cpp @@ -116,10 +116,10 @@ static void WINRT_ProcessWindowSizeChange() // TODO: Pass an SDL_Window-identify SDL_Window *window = WINRT_GlobalSDLWindow; SDL_WindowData *data = (SDL_WindowData *)window->driverdata; - int x = WINRT_DIPS_TO_PHYSICAL_PIXELS(data->coreWindow->Bounds.Left); - int y = WINRT_DIPS_TO_PHYSICAL_PIXELS(data->coreWindow->Bounds.Top); - int w = WINRT_DIPS_TO_PHYSICAL_PIXELS(data->coreWindow->Bounds.Width); - int h = WINRT_DIPS_TO_PHYSICAL_PIXELS(data->coreWindow->Bounds.Height); + int x = (int)SDL_lroundf(data->coreWindow->Bounds.Left); + int y = (int)SDL_lroundf(data->coreWindow->Bounds.Top); + int w = (int)SDL_floorf(data->coreWindow->Bounds.Width); + int h = (int)SDL_floorf(data->coreWindow->Bounds.Height); #if (WINAPI_FAMILY == WINAPI_FAMILY_PHONE_APP) && (NTDDI_VERSION == NTDDI_WIN8) /* WinPhone 8.0 always keeps its native window size in portrait, @@ -235,8 +235,8 @@ void SDL_WinRTApp::OnOrientationChanged(Object ^ sender) SDL_Window *window = WINRT_GlobalSDLWindow; if (window) { SDL_WindowData *data = (SDL_WindowData *)window->driverdata; - int w = WINRT_DIPS_TO_PHYSICAL_PIXELS(data->coreWindow->Bounds.Width); - int h = WINRT_DIPS_TO_PHYSICAL_PIXELS(data->coreWindow->Bounds.Height); + int w = (int)SDL_floorf(data->coreWindow->Bounds.Width); + int h = (int)SDL_floorf(data->coreWindow->Bounds.Height); SDL_SendWindowEvent(WINRT_GlobalSDLWindow, SDL_EVENT_WINDOW_SIZE_CHANGED, w, h); } #endif diff --git a/src/test/SDL_test_common.c b/src/test/SDL_test_common.c index 9bf5a85e5..8b961ec86 100644 --- a/src/test/SDL_test_common.c +++ b/src/test/SDL_test_common.c @@ -1130,7 +1130,7 @@ SDLTest_CommonInit(SDLTest_CommonState *state) SDL_GetMasksForPixelFormatEnum(mode.format, &bpp, &Rmask, &Gmask, &Bmask, &Amask); SDL_Log(" Current mode: %dx%d@%gHz, %d%% scale, %d bits-per-pixel (%s)\n", - mode.w, mode.h, mode.refresh_rate, (int)(mode.display_scale * 100.0f), bpp, + mode.pixel_w, mode.pixel_h, mode.refresh_rate, (int)(mode.display_scale * 100.0f), bpp, SDL_GetPixelFormatName(mode.format)); if (Rmask || Gmask || Bmask) { SDL_Log(" Red Mask = 0x%.8" SDL_PRIx32 "\n", Rmask); @@ -1152,7 +1152,7 @@ SDLTest_CommonInit(SDLTest_CommonState *state) SDL_GetMasksForPixelFormatEnum(mode.format, &bpp, &Rmask, &Gmask, &Bmask, &Amask); SDL_Log(" Mode %d: %dx%d@%gHz, %d%% scale, %d bits-per-pixel (%s)\n", - j, mode.w, mode.h, mode.refresh_rate, (int)(mode.display_scale * 100.0f), bpp, + j, mode.pixel_w, mode.pixel_h, mode.refresh_rate, (int)(mode.display_scale * 100.0f), bpp, SDL_GetPixelFormatName(mode.format)); if (Rmask || Gmask || Bmask) { SDL_Log(" Red Mask = 0x%.8" SDL_PRIx32 "\n", @@ -2246,7 +2246,7 @@ void SDLTest_CommonDrawWindowInfo(SDL_Renderer *renderer, SDL_Window *window, fl if (0 == SDL_GetWindowDisplayMode(window, &mode)) { (void)SDL_snprintf(text, sizeof text, "SDL_GetWindowDisplayMode: %dx%d@%gHz %d%% scale, (%s)", - mode.w, mode.h, mode.refresh_rate, (int)(mode.display_scale * 100.0f), SDL_GetPixelFormatName(mode.format)); + mode.pixel_w, mode.pixel_h, mode.refresh_rate, (int)(mode.display_scale * 100.0f), SDL_GetPixelFormatName(mode.format)); SDLTest_DrawString(renderer, 0.0f, textY, text); textY += lineHeight; } @@ -2276,14 +2276,14 @@ void SDLTest_CommonDrawWindowInfo(SDL_Renderer *renderer, SDL_Window *window, fl if (0 == SDL_GetCurrentDisplayMode(windowDisplayIndex, &mode)) { (void)SDL_snprintf(text, sizeof text, "SDL_GetCurrentDisplayMode: %dx%d@%gHz %d%% scale, (%s)", - mode.w, mode.h, mode.refresh_rate, (int)(mode.display_scale * 100.0f), SDL_GetPixelFormatName(mode.format)); + mode.pixel_w, mode.pixel_h, mode.refresh_rate, (int)(mode.display_scale * 100.0f), SDL_GetPixelFormatName(mode.format)); SDLTest_DrawString(renderer, 0.0f, textY, text); textY += lineHeight; } if (0 == SDL_GetDesktopDisplayMode(windowDisplayIndex, &mode)) { (void)SDL_snprintf(text, sizeof text, "SDL_GetDesktopDisplayMode: %dx%d@%gHz %d%% scale, (%s)", - mode.w, mode.h, mode.refresh_rate, (int)(mode.display_scale * 100.0f), SDL_GetPixelFormatName(mode.format)); + mode.pixel_w, mode.pixel_h, mode.refresh_rate, (int)(mode.display_scale * 100.0f), SDL_GetPixelFormatName(mode.format)); SDLTest_DrawString(renderer, 0.0f, textY, text); textY += lineHeight; } diff --git a/src/video/SDL_video.c b/src/video/SDL_video.c index 9b8f2f931..8d4288d88 100644 --- a/src/video/SDL_video.c +++ b/src/video/SDL_video.c @@ -382,16 +382,16 @@ static int SDLCALL cmpmodes(const void *A, const void *B) { const SDL_DisplayMode *a = (const SDL_DisplayMode *)A; const SDL_DisplayMode *b = (const SDL_DisplayMode *)B; - float a_display_scale = (a->display_scale == 0.0f) ? 1.0f : a->display_scale; - float b_display_scale = (b->display_scale == 0.0f) ? 1.0f : b->display_scale; if (a == b) { return 0; - } else if (a->w != b->w) { - return b->w - a->w; - } else if (a->h != b->h) { - return b->h - a->h; - } else if (a_display_scale != b_display_scale) { - return (int)(a_display_scale * 100) - (int)(b_display_scale * 100); + } else if (a->screen_w != b->screen_w) { + return b->screen_w - a->screen_w; + } else if (a->screen_h != b->screen_h) { + return b->screen_h - a->screen_h; + } else if (a->pixel_w != b->pixel_w) { + return b->pixel_w - a->pixel_w; + } else if (a->pixel_h != b->pixel_h) { + return b->pixel_h - a->pixel_h; } else if (SDL_BITSPERPIXEL(a->format) != SDL_BITSPERPIXEL(b->format)) { return SDL_BITSPERPIXEL(b->format) - SDL_BITSPERPIXEL(a->format); } else if (SDL_PIXELLAYOUT(a->format) != SDL_PIXELLAYOUT(b->format)) { @@ -585,6 +585,40 @@ SDL_bool SDL_OnVideoThread() return (_this && SDL_ThreadID() == _this->thread) ? SDL_TRUE : SDL_FALSE; } +static void SDL_FinalizeDisplayMode(SDL_DisplayMode *mode) +{ + /* Make sure all the fields are set up correctly */ + if (mode->display_scale <= 0.0f) { + if (mode->screen_w == 0 && mode->screen_h == 0) { + mode->screen_w = mode->pixel_w; + mode->screen_h = mode->pixel_h; + } + if (mode->pixel_w == 0 && mode->pixel_h == 0) { + mode->pixel_w = mode->screen_w; + mode->pixel_h = mode->screen_h; + } + if (mode->screen_w > 0) { + mode->display_scale = (float)mode->pixel_w / mode->screen_w; + } + } else { + if (mode->screen_w == 0 && mode->screen_h == 0) { + mode->screen_w = (int)SDL_floorf(mode->pixel_w / mode->display_scale); + mode->screen_h = (int)SDL_floorf(mode->pixel_h / mode->display_scale); + } + if (mode->pixel_w == 0 && mode->pixel_h == 0) { + mode->pixel_w = (int)SDL_ceilf(mode->screen_w * mode->display_scale); + mode->pixel_h = (int)SDL_ceilf(mode->screen_h * mode->display_scale); + } + } + + /* Make sure the screen width, pixel width, and display scale all match */ + if (mode->display_scale != 0.0f) { + SDL_assert(mode->display_scale > 0.0f); + SDL_assert(SDL_fabsf(mode->screen_w - (mode->pixel_w / mode->display_scale)) < 1.0f); + SDL_assert(SDL_fabsf(mode->screen_h - (mode->pixel_h / mode->display_scale)) < 1.0f); + } +} + int SDL_AddBasicVideoDisplay(const SDL_DisplayMode *desktop_mode) { SDL_VideoDisplay display; @@ -592,9 +626,7 @@ int SDL_AddBasicVideoDisplay(const SDL_DisplayMode *desktop_mode) SDL_zero(display); if (desktop_mode) { display.desktop_mode = *desktop_mode; - if (display.desktop_mode.display_scale == 0.0f) { - display.desktop_mode.display_scale = 1.0f; - } + SDL_FinalizeDisplayMode(&display.desktop_mode); } display.current_mode = display.desktop_mode; @@ -624,12 +656,9 @@ int SDL_AddVideoDisplay(const SDL_VideoDisplay *display, SDL_bool send_event) displays[index].name = SDL_strdup(name); } - if (displays[index].desktop_mode.display_scale == 0.0f) { - displays[index].desktop_mode.display_scale = 1.0f; - } - if (displays[index].current_mode.display_scale == 0.0f) { - displays[index].current_mode.display_scale = 1.0f; - } + SDL_FinalizeDisplayMode(&displays[index].desktop_mode); + SDL_FinalizeDisplayMode(&displays[index].current_mode); + if (send_event) { SDL_SendDisplayEvent(&_this->displays[index], SDL_EVENT_DISPLAY_CONNECTED, 0); } @@ -722,8 +751,8 @@ int SDL_GetDisplayBounds(int displayIndex, SDL_Rect *rect) SDL_GetDisplayBounds(displayIndex - 1, rect); rect->x += rect->w; } - rect->w = (int)(display->current_mode.w / display->current_mode.display_scale); - rect->h = (int)(display->current_mode.h / display->current_mode.display_scale); + rect->w = display->current_mode.screen_w; + rect->h = display->current_mode.screen_h; return 0; } @@ -812,9 +841,7 @@ SDL_bool SDL_AddDisplayMode(SDL_VideoDisplay *display, const SDL_DisplayMode *mo display->max_display_modes += 32; } modes[nmodes] = *mode; - if (modes[nmodes].display_scale == 0.0f) { - modes[nmodes].display_scale = 1.0f; - } + SDL_FinalizeDisplayMode(&modes[nmodes]); display->num_display_modes++; /* Re-sort video modes */ @@ -827,17 +854,13 @@ SDL_bool SDL_AddDisplayMode(SDL_VideoDisplay *display, const SDL_DisplayMode *mo void SDL_SetCurrentDisplayMode(SDL_VideoDisplay *display, const SDL_DisplayMode *mode) { SDL_memcpy(&display->current_mode, mode, sizeof(*mode)); - if (display->current_mode.display_scale == 0.0f) { - display->current_mode.display_scale = 1.0f; - } + SDL_FinalizeDisplayMode(&display->current_mode); } void SDL_SetDesktopDisplayMode(SDL_VideoDisplay *display, const SDL_DisplayMode *mode) { SDL_memcpy(&display->desktop_mode, mode, sizeof(*mode)); - if (display->desktop_mode.display_scale == 0.0f) { - display->desktop_mode.display_scale = 1.0f; - } + SDL_FinalizeDisplayMode(&display->desktop_mode); } static int SDL_GetNumDisplayModesForDisplay(SDL_VideoDisplay *display) @@ -922,9 +945,9 @@ static SDL_DisplayMode *SDL_GetClosestDisplayModeForDisplay(SDL_VideoDisplay *di SDL_DisplayMode *closest) { Uint32 target_format; - float target_display_scale; float target_refresh_rate; int i; + SDL_DisplayMode requested_mode; SDL_DisplayMode *current, *match; if (mode == NULL || closest == NULL) { @@ -932,6 +955,11 @@ static SDL_DisplayMode *SDL_GetClosestDisplayModeForDisplay(SDL_VideoDisplay *di return NULL; } + /* Make sure all the fields are filled out in the requested mode */ + requested_mode = *mode; + SDL_FinalizeDisplayMode(&requested_mode); + mode = &requested_mode; + /* Default to the desktop format */ if (mode->format) { target_format = mode->format; @@ -939,13 +967,6 @@ static SDL_DisplayMode *SDL_GetClosestDisplayModeForDisplay(SDL_VideoDisplay *di target_format = display->desktop_mode.format; } - /* Default to 1.0 scale */ - if (mode->display_scale > 0.0f) { - target_display_scale = mode->display_scale; - } else { - target_display_scale = 1.0f; - } - /* Default to the desktop refresh rate */ if (mode->refresh_rate > 0.0f) { target_refresh_rate = mode->refresh_rate; @@ -957,12 +978,12 @@ static SDL_DisplayMode *SDL_GetClosestDisplayModeForDisplay(SDL_VideoDisplay *di for (i = 0; i < SDL_GetNumDisplayModesForDisplay(display); ++i) { current = &display->display_modes[i]; - if (current->w && (current->w < mode->w)) { + if (current->pixel_w && (current->pixel_w < mode->pixel_w)) { /* Out of sorted modes large enough here */ break; } - if (current->h && (current->h < mode->h)) { - if (current->w && (current->w == mode->w)) { + if (current->pixel_h && (current->pixel_h < mode->pixel_h)) { + if (current->pixel_w && (current->pixel_w == mode->pixel_w)) { /* Out of sorted modes large enough here */ break; } @@ -971,7 +992,7 @@ static SDL_DisplayMode *SDL_GetClosestDisplayModeForDisplay(SDL_VideoDisplay *di modes may still follow. */ continue; } - if (match == NULL || current->w < match->w || current->h < match->h) { + if (match == NULL || current->pixel_w < match->pixel_w || current->pixel_h < match->pixel_h) { match = current; continue; } @@ -993,35 +1014,29 @@ static SDL_DisplayMode *SDL_GetClosestDisplayModeForDisplay(SDL_VideoDisplay *di continue; } } - if (current->display_scale != match->display_scale) { - /* Sorted lowest display scale to highest */ - if (current->display_scale <= target_display_scale) { - match = current; - continue; - } - } } + if (match) { + SDL_zerop(closest); if (match->format) { closest->format = match->format; } else { closest->format = mode->format; } - if (match->w && match->h) { - closest->w = match->w; - closest->h = match->h; + if (match->screen_w && match->screen_h) { + closest->screen_w = match->screen_w; + closest->screen_h = match->screen_h; } else { - closest->w = mode->w; - closest->h = mode->h; + closest->screen_w = mode->screen_w; + closest->screen_h = mode->screen_h; } - if (match->display_scale > 0.0f) { - closest->display_scale = match->display_scale; - } else if (mode->display_scale > 0.0f) { - closest->display_scale = mode->display_scale; + if (match->pixel_w && match->pixel_h) { + closest->pixel_w = match->pixel_w; + closest->pixel_h = match->pixel_h; } else { - closest->display_scale = 1.0f; + closest->pixel_w = mode->pixel_w; + closest->pixel_h = mode->pixel_h; } - if (match->refresh_rate > 0.0f) { closest->refresh_rate = match->refresh_rate; } else { @@ -1029,19 +1044,17 @@ static SDL_DisplayMode *SDL_GetClosestDisplayModeForDisplay(SDL_VideoDisplay *di } closest->driverdata = match->driverdata; - /* - * Pick some reasonable defaults if the app and driver don't - * care - */ + /* Pick some reasonable defaults if the app and driver don't care */ if (!closest->format) { closest->format = SDL_PIXELFORMAT_RGB888; } - if (!closest->w) { - closest->w = 640; + if (!closest->screen_w) { + closest->screen_w = 640; } - if (!closest->h) { - closest->h = 480; + if (!closest->screen_h) { + closest->screen_h = 480; } + SDL_FinalizeDisplayMode(closest); return closest; } return NULL; @@ -1075,11 +1088,17 @@ static int SDL_SetDisplayModeForDisplay(SDL_VideoDisplay *display, const SDL_Dis if (!display_mode.format) { display_mode.format = display->current_mode.format; } - if (!display_mode.w) { - display_mode.w = display->current_mode.w; + if (!display_mode.pixel_w) { + display_mode.pixel_w = display->current_mode.pixel_w; } - if (!display_mode.h) { - display_mode.h = display->current_mode.h; + if (!display_mode.pixel_h) { + display_mode.pixel_h = display->current_mode.pixel_h; + } + if (!display_mode.screen_w) { + display_mode.screen_w = display->current_mode.screen_w; + } + if (!display_mode.screen_h) { + display_mode.screen_h = display->current_mode.screen_h; } if (display_mode.refresh_rate == 0.0f) { display_mode.refresh_rate = display->current_mode.refresh_rate; @@ -1087,7 +1106,9 @@ static int SDL_SetDisplayModeForDisplay(SDL_VideoDisplay *display, const SDL_Dis /* Get a good video mode, the closest one possible */ if (!SDL_GetClosestDisplayModeForDisplay(display, &display_mode, &display_mode)) { - return SDL_SetError("No video mode large enough for %dx%d", display_mode.w, display_mode.h); + return SDL_SetError("No video mode large enough for %dx%d (%dx%d)", + display_mode.pixel_w, display_mode.pixel_h, + display_mode.screen_w, display_mode.screen_h); } } else { display_mode = display->desktop_mode; @@ -1284,11 +1305,11 @@ int SDL_SetWindowDisplayMode(SDL_Window *window, const SDL_DisplayMode *mode) #ifndef __ANDROID__ /* Android may not resize the window to exactly what our fullscreen mode is, especially on * windowed Android environments like the Chromebook or Samsung DeX. Given this, we shouldn't - * use fullscreen_mode.w and fullscreen_mode.h, but rather get our current native size. As such, + * use fullscreen_mode.screen_w and fullscreen_mode.screen_h, but rather get our current native size. As such, * Android's SetWindowFullscreen will generate the window event for us with the proper final size. */ - SDL_SendWindowEvent(window, SDL_EVENT_WINDOW_RESIZED, fullscreen_mode.w, fullscreen_mode.h); -#endif + SDL_SendWindowEvent(window, SDL_EVENT_WINDOW_RESIZED, fullscreen_mode.screen_w, fullscreen_mode.screen_h); +#endif /* !__ANDROID__ */ } } } @@ -1307,11 +1328,11 @@ int SDL_GetWindowDisplayMode(SDL_Window *window, SDL_DisplayMode *mode) } fullscreen_mode = window->fullscreen_mode; - if (!fullscreen_mode.w) { - fullscreen_mode.w = window->windowed.w; + if (!fullscreen_mode.screen_w) { + fullscreen_mode.screen_w = window->windowed.w; } - if (!fullscreen_mode.h) { - fullscreen_mode.h = window->windowed.h; + if (!fullscreen_mode.screen_h) { + fullscreen_mode.screen_h = window->windowed.h; } display = SDL_GetDisplayForWindow(window); @@ -1469,7 +1490,7 @@ static int SDL_UpdateFullscreenMode(SDL_Window *window, SDL_bool fullscreen) if (SDL_GetWindowDisplayMode(other, &fullscreen_mode) == 0) { SDL_bool resized = SDL_TRUE; - if (other->w == fullscreen_mode.w && other->h == fullscreen_mode.h) { + if (other->w == fullscreen_mode.screen_w && other->h == fullscreen_mode.screen_h) { resized = SDL_FALSE; } @@ -1501,11 +1522,8 @@ static int SDL_UpdateFullscreenMode(SDL_Window *window, SDL_bool fullscreen) /* This is also unnecessary on Win32 (WIN_SetWindowFullscreen calls SetWindowPos, * WM_WINDOWPOSCHANGED will send SDL_EVENT_WINDOW_RESIZED). */ - - /* The new fullscreen window size must be sent in screen coordinates, not pixels. */ SDL_SendWindowEvent(other, SDL_EVENT_WINDOW_RESIZED, - (int)(fullscreen_mode.w / fullscreen_mode.display_scale), - (int)(fullscreen_mode.h / fullscreen_mode.display_scale)); + fullscreen_mode.screen_w, fullscreen_mode.screen_h); #endif } else { SDL_OnWindowResized(other); @@ -1745,15 +1763,15 @@ SDL_Window *SDL_CreateWindow(const char *title, int x, int y, int w, int h, Uint if ((flags & SDL_WINDOW_FULLSCREEN_DESKTOP) != SDL_WINDOW_FULLSCREEN_DESKTOP && (bounds.w != w || bounds.h != h)) { SDL_DisplayMode fullscreen_mode, closest_mode; SDL_zero(fullscreen_mode); - fullscreen_mode.w = w; - fullscreen_mode.h = h; + fullscreen_mode.screen_w = w; + fullscreen_mode.screen_h = h; if (SDL_GetClosestDisplayModeForDisplay(display, &fullscreen_mode, &closest_mode) != NULL) { - bounds.w = closest_mode.w; - bounds.h = closest_mode.h; + bounds.w = closest_mode.screen_w; + bounds.h = closest_mode.screen_h; } } - window->fullscreen_mode.w = bounds.w; - window->fullscreen_mode.h = bounds.h; + window->fullscreen_mode.screen_w = bounds.w; + window->fullscreen_mode.screen_h = bounds.h; window->x = bounds.x; window->y = bounds.y; window->w = bounds.w; @@ -2409,8 +2427,16 @@ void SDL_GetWindowSizeInPixels(SDL_Window *window, int *w, int *h) if (display) { - *w = (int)SDL_ceilf(*w * display->current_mode.display_scale); - *h = (int)SDL_ceilf(*h * display->current_mode.display_scale); + if (*w == display->current_mode.screen_w) { + *w = display->current_mode.pixel_w; + } else { + *w = (int)SDL_ceilf(*w * display->current_mode.display_scale); + } + if (*h == display->current_mode.screen_h) { + *h = display->current_mode.pixel_h; + } else { + *h = (int)SDL_ceilf(*h * display->current_mode.display_scale); + } } } } @@ -2999,8 +3025,8 @@ void SDL_OnWindowDisplayChanged(SDL_Window *window) window->y = rect.y; window->w = rect.w; window->h = rect.h; - window->fullscreen_mode.w = rect.w; - window->fullscreen_mode.h = rect.h; + window->fullscreen_mode.screen_w = rect.w; + window->fullscreen_mode.screen_h = rect.h; if (_this->SetWindowSize) { _this->SetWindowSize(_this, window); } diff --git a/src/video/android/SDL_androidvideo.c b/src/video/android/SDL_androidvideo.c index ca1969fa2..562df5ed9 100644 --- a/src/video/android/SDL_androidvideo.c +++ b/src/video/android/SDL_androidvideo.c @@ -180,8 +180,8 @@ int Android_VideoInit(_THIS) SDL_zero(mode); mode.format = Android_ScreenFormat; - mode.w = Android_DeviceWidth; - mode.h = Android_DeviceHeight; + mode.pixel_w = Android_DeviceWidth; + mode.pixel_h = Android_DeviceHeight; mode.display_scale = Android_ScreenDensity; mode.refresh_rate = Android_ScreenRate; mode.driverdata = NULL; @@ -276,11 +276,15 @@ void Android_SendResize(SDL_Window *window) SDL_VideoDevice *device = SDL_GetVideoDevice(); if (device && device->num_displays > 0) { SDL_VideoDisplay *display = &device->displays[0]; - display->desktop_mode.format = Android_ScreenFormat; - display->desktop_mode.w = Android_DeviceWidth; - display->desktop_mode.h = Android_DeviceHeight; - display->desktop_mode.display_scale = Android_ScreenDensity; - display->desktop_mode.refresh_rate = Android_ScreenRate; + SDL_DisplayMode desktop_mode; + + SDL_zero(desktop_mode); + desktop_mode.format = Android_ScreenFormat; + desktop_mode.pixel_w = Android_DeviceWidth; + desktop_mode.pixel_h = Android_DeviceHeight; + desktop_mode.display_scale = Android_ScreenDensity; + desktop_mode.refresh_rate = Android_ScreenRate; + SDL_SetDesktopDisplayMode(display, &desktop_mode); } if (window) { @@ -288,15 +292,17 @@ void Android_SendResize(SDL_Window *window) * will fall back to the old mode */ int w, h; SDL_VideoDisplay *display = SDL_GetDisplayForWindow(window); - display->display_modes[0].format = Android_ScreenFormat; - display->display_modes[0].w = Android_DeviceWidth; - display->display_modes[0].h = Android_DeviceHeight; - display->display_modes[0].display_scale = Android_ScreenDensity; - display->display_modes[0].refresh_rate = Android_ScreenRate; - display->current_mode = display->display_modes[0]; + SDL_DisplayMode current_mode; - w = (int)SDL_ceilf(Android_SurfaceWidth / Android_ScreenDensity); - h = (int)SDL_ceilf(Android_SurfaceHeight / Android_ScreenDensity); + current_mode.format = Android_ScreenFormat; + current_mode.pixel_w = Android_DeviceWidth; + current_mode.pixel_h = Android_DeviceHeight; + current_mode.display_scale = Android_ScreenDensity; + current_mode.refresh_rate = Android_ScreenRate; + SDL_SetCurrentDisplayMode(display, ¤t_mode); + + w = (int)SDL_floorf(Android_SurfaceWidth / Android_ScreenDensity); + h = (int)SDL_floorf(Android_SurfaceHeight / Android_ScreenDensity); SDL_SendWindowEvent(window, SDL_EVENT_WINDOW_RESIZED, w, h); } } diff --git a/src/video/cocoa/SDL_cocoamodes.m b/src/video/cocoa/SDL_cocoamodes.m index cc2afdc40..ecb71d7f2 100644 --- a/src/video/cocoa/SDL_cocoamodes.m +++ b/src/video/cocoa/SDL_cocoamodes.m @@ -143,10 +143,10 @@ static SDL_bool GetDisplayMode(_THIS, CGDisplayModeRef vidmode, SDL_bool vidmode { SDL_DisplayModeData *data; bool usableForGUI = CGDisplayModeIsUsableForDesktopGUI(vidmode); - int width = (int)CGDisplayModeGetWidth(vidmode); - int height = (int)CGDisplayModeGetHeight(vidmode); - int pixelW = width; - int pixelH = height; + size_t width = CGDisplayModeGetWidth(vidmode); + size_t height = CGDisplayModeGetHeight(vidmode); + size_t pixelW = width; + size_t pixelH = height; uint32_t ioflags = CGDisplayModeGetIOFlags(vidmode); float refreshrate = GetDisplayModeRefreshRate(vidmode, link); Uint32 format = GetDisplayModePixelFormat(vidmode); @@ -173,15 +173,15 @@ static SDL_bool GetDisplayMode(_THIS, CGDisplayModeRef vidmode, SDL_bool vidmode * modes to try (see comment below for why that's necessary). * CGDisplayModeGetPixelWidth and friends are only available in 10.8+. */ #ifdef MAC_OS_X_VERSION_10_8 - pixelW = (int)CGDisplayModeGetPixelWidth(vidmode); - pixelH = (int)CGDisplayModeGetPixelHeight(vidmode); + pixelW = CGDisplayModeGetPixelWidth(vidmode); + pixelH = CGDisplayModeGetPixelHeight(vidmode); if (modelist != NULL && floor(NSAppKitVersionNumber) > NSAppKitVersionNumber10_7) { CFIndex modescount = CFArrayGetCount(modelist); int i; for (i = 0; i < modescount; i++) { - int otherW, otherH, otherpixelW, otherpixelH; + size_t otherW, otherH, otherpixelW, otherpixelH; float otherrefresh; Uint32 otherformat; bool otherGUI; @@ -196,10 +196,10 @@ static SDL_bool GetDisplayMode(_THIS, CGDisplayModeRef vidmode, SDL_bool vidmode continue; } - otherW = (int)CGDisplayModeGetWidth(othermode); - otherH = (int)CGDisplayModeGetHeight(othermode); - otherpixelW = (int)CGDisplayModeGetPixelWidth(othermode); - otherpixelH = (int)CGDisplayModeGetPixelHeight(othermode); + otherW = CGDisplayModeGetWidth(othermode); + otherH = CGDisplayModeGetHeight(othermode); + otherpixelW = CGDisplayModeGetPixelWidth(othermode); + otherpixelH = CGDisplayModeGetPixelHeight(othermode); otherrefresh = GetDisplayModeRefreshRate(othermode, link); otherformat = GetDisplayModePixelFormat(othermode); otherGUI = CGDisplayModeIsUsableForDesktopGUI(othermode); @@ -264,9 +264,10 @@ static SDL_bool GetDisplayMode(_THIS, CGDisplayModeRef vidmode, SDL_bool vidmode } data->modes = modes; mode->format = format; - mode->w = pixelW; - mode->h = pixelH; - mode->display_scale = (float)pixelW / width; + mode->pixel_w = (int)pixelW; + mode->pixel_h = (int)pixelH; + mode->screen_w = (int)width; + mode->screen_h = (int)height; mode->refresh_rate = refreshrate; mode->driverdata = data; return SDL_TRUE; diff --git a/src/video/dummy/SDL_nullvideo.c b/src/video/dummy/SDL_nullvideo.c index 1bb617127..7f33b9c7a 100644 --- a/src/video/dummy/SDL_nullvideo.c +++ b/src/video/dummy/SDL_nullvideo.c @@ -144,8 +144,8 @@ int DUMMY_VideoInit(_THIS) /* Use a fake 32-bpp desktop mode */ SDL_zero(mode); mode.format = SDL_PIXELFORMAT_RGB888; - mode.w = 1024; - mode.h = 768; + mode.pixel_w = 1024; + mode.pixel_h = 768; if (SDL_AddBasicVideoDisplay(&mode) < 0) { return -1; } diff --git a/src/video/emscripten/SDL_emscriptenvideo.c b/src/video/emscripten/SDL_emscriptenvideo.c index bb22d7e08..9c73a8539 100644 --- a/src/video/emscripten/SDL_emscriptenvideo.c +++ b/src/video/emscripten/SDL_emscriptenvideo.c @@ -129,7 +129,8 @@ int Emscripten_VideoInit(_THIS) /* Use a fake 32-bpp desktop mode */ SDL_zero(mode); mode.format = SDL_PIXELFORMAT_RGB888; - emscripten_get_screen_size(&mode.w, &mode.h); + emscripten_get_screen_size(&mode.screen_w, &mode.screen_h); + mode.display_scale = emscripten_get_device_pixel_ratio(); if (SDL_AddBasicVideoDisplay(&mode) < 0) { return -1; diff --git a/src/video/haiku/SDL_bmodes.cc b/src/video/haiku/SDL_bmodes.cc index 147bae41d..3694f4a83 100644 --- a/src/video/haiku/SDL_bmodes.cc +++ b/src/video/haiku/SDL_bmodes.cc @@ -78,7 +78,7 @@ static float get_refresh_rate(display_mode &mode) { void _SpoutModeData(display_mode *bmode) { printf("BMode:\n"); printf("\tw,h = (%i,%i)\n", bmode->virtual_width, bmode->virtual_height); - printf("\th,v = (%i,%i)\n", bmode->h_display_start, + printf("\th,v = (%i,%i)\n", bmode->h_display_start, bmode->v_display_start); if (bmode->flags) { printf("\tFlags:\n"); @@ -162,25 +162,23 @@ int32 HAIKU_ColorSpaceToSDLPxFormat(uint32 colorspace) /* May never get here, but safer and needed to shut up compiler */ SDL_SetError("Invalid color space"); - return 0; + return 0; } -static void _BDisplayModeToSdlDisplayMode(display_mode *bmode, - SDL_DisplayMode *mode) { +static void _BDisplayModeToSdlDisplayMode(display_mode *bmode, SDL_DisplayMode *mode) { SDL_zerop(mode); - mode->w = bmode->virtual_width; - mode->h = bmode->virtual_height; + mode->pixel_w = bmode->virtual_width; + mode->pixel_h = bmode->virtual_height; mode->refresh_rate = get_refresh_rate(*bmode); #if WRAP_BMODE SDL_DisplayModeData *data = (SDL_DisplayModeData*)SDL_calloc(1, sizeof(SDL_DisplayModeData)); data->bmode = bmode; - + mode->driverdata = data; #else - mode->driverdata = bmode; #endif @@ -190,19 +188,13 @@ static void _BDisplayModeToSdlDisplayMode(display_mode *bmode, /* Later, there may be more than one monitor available */ static void _AddDisplay(BScreen *screen) { - SDL_VideoDisplay display; - SDL_DisplayMode *mode = (SDL_DisplayMode*)SDL_calloc(1, - sizeof(SDL_DisplayMode)); - display_mode *bmode = (display_mode*)SDL_calloc(1, sizeof(display_mode)); - screen->GetMode(bmode); + SDL_DisplayMode mode; + display_mode bmode; + screen->GetMode(&bmode); - _BDisplayModeToSdlDisplayMode(bmode, mode); - - SDL_zero(display); - display.desktop_mode = *mode; - display.current_mode = *mode; - - SDL_AddVideoDisplay(&display, SDL_FALSE); + _BDisplayModeToSdlDisplayMode(&bmode, &mode); + + SDL_AddBasicVideoDisplay(&mode); } /* @@ -243,11 +235,11 @@ void HAIKU_GetDisplayModes(_THIS, SDL_VideoDisplay *display) { display_mode this_bmode; display_mode *bmodes; uint32 count, i; - + /* Get graphics-hardware supported modes */ bscreen.GetModeList(&bmodes, &count); bscreen.GetMode(&this_bmode); - + for (i = 0; i < count; ++i) { // FIXME: Apparently there are errors with colorspace changes if (bmodes[i].space == this_bmode.space) { @@ -286,9 +278,9 @@ int HAIKU_SetDisplayMode(_THIS, SDL_VideoDisplay *display, SDL_DisplayMode *mode if (bscreen.SetMode(bmode) != B_OK) { return SDL_SetError("Bad video mode"); } - + free(bmode_list); /* This should not be SDL_free() */ - + #if SDL_VIDEO_OPENGL /* FIXME: Is there some way to reboot the OpenGL context? This doesn't help */ diff --git a/src/video/kmsdrm/SDL_kmsdrmvideo.c b/src/video/kmsdrm/SDL_kmsdrmvideo.c index 1db906aa1..55009f374 100644 --- a/src/video/kmsdrm/SDL_kmsdrmvideo.c +++ b/src/video/kmsdrm/SDL_kmsdrmvideo.c @@ -501,11 +501,10 @@ static drmModeModeInfo *KMSDRM_GetClosestDisplayMode(SDL_VideoDisplay *display, SDL_DisplayMode target, closest; drmModeModeInfo *drm_mode; - target.w = width; - target.h = height; - target.format = 0; /* Will use the default mode format. */ - target.refresh_rate = refresh_rate; - target.driverdata = 0; /* Initialize to 0 */ + SDL_zero(target); + target.pixel_w = (int)width; + target.pixel_h = (int)height; + target.refresh_rate = (int)refresh_rate; if (!SDL_GetClosestDisplayMode(SDL_atoi(display->name), &target, &closest)) { return NULL; @@ -871,8 +870,8 @@ static void KMSDRM_AddDisplay(_THIS, drmModeConnector *connector, drmModeRes *re modedata->mode_index = mode_index; display.driverdata = dispdata; - display.desktop_mode.w = dispdata->mode.hdisplay; - display.desktop_mode.h = dispdata->mode.vdisplay; + display.desktop_mode.pixel_w = dispdata->mode.hdisplay; + display.desktop_mode.pixel_h = dispdata->mode.vdisplay; display.desktop_mode.refresh_rate = CalculateRefreshRate(&dispdata->mode); display.desktop_mode.format = SDL_PIXELFORMAT_ARGB8888; display.desktop_mode.driverdata = modedata; @@ -1158,6 +1157,7 @@ int KMSDRM_CreateSurfaces(_THIS, SDL_Window *window) SDL_WindowData *windata = (SDL_WindowData *)window->driverdata; SDL_VideoDisplay *display = SDL_GetDisplayForWindow(window); SDL_DisplayData *dispdata = (SDL_DisplayData *)display->driverdata; + SDL_DisplayMode current_mode; uint32_t surface_fmt = GBM_FORMAT_ARGB8888; uint32_t surface_flags = GBM_BO_USE_SCANOUT | GBM_BO_USE_RENDERING; @@ -1182,10 +1182,12 @@ int KMSDRM_CreateSurfaces(_THIS, SDL_Window *window) mode that's set in sync with what SDL_video.c thinks is set */ KMSDRM_GetModeToSet(window, &dispdata->mode); - display->current_mode.w = dispdata->mode.hdisplay; - display->current_mode.h = dispdata->mode.vdisplay; - display->current_mode.refresh_rate = CalculateRefreshRate(&dispdata->mode); - display->current_mode.format = SDL_PIXELFORMAT_ARGB8888; + SDL_zero(current_mode); + current_mode.pixel_w = dispdata->mode.hdisplay; + current_mode.pixel_h = dispdata->mode.vdisplay; + current_mode.refresh_rate = CalculateRefreshRate(&dispdata->mode); + current_mode.format = SDL_PIXELFORMAT_ARGB8888; + SDL_SetCurrentDisplayMode(display, ¤t_mode); windata->gs = KMSDRM_gbm_surface_create(viddata->gbm_dev, dispdata->mode.hdisplay, dispdata->mode.vdisplay, diff --git a/src/video/n3ds/SDL_n3dsvideo.c b/src/video/n3ds/SDL_n3dsvideo.c index 9b43206be..1faa9f853 100644 --- a/src/video/n3ds/SDL_n3dsvideo.c +++ b/src/video/n3ds/SDL_n3dsvideo.c @@ -118,8 +118,8 @@ AddN3DSDisplay(gfxScreen_t screen) display_driver_data->screen = screen; - mode.w = (screen == GFX_TOP) ? GSP_SCREEN_HEIGHT_TOP : GSP_SCREEN_HEIGHT_BOTTOM; - mode.h = GSP_SCREEN_WIDTH; + mode.pixel_w = (screen == GFX_TOP) ? GSP_SCREEN_HEIGHT_TOP : GSP_SCREEN_HEIGHT_BOTTOM; + mode.pixel_h = GSP_SCREEN_WIDTH; mode.refresh_rate = 60.0f; mode.format = FRAMEBUFFER_FORMAT; @@ -154,8 +154,8 @@ static int N3DS_GetDisplayBounds(_THIS, SDL_VideoDisplay *display, SDL_Rect *rec } rect->x = 0; rect->y = (driver_data->screen == GFX_TOP) ? 0 : GSP_SCREEN_WIDTH; - rect->w = display->current_mode.w; - rect->h = display->current_mode.h; + rect->w = display->current_mode.screen_w; + rect->h = display->current_mode.screen_h; return 0; } diff --git a/src/video/ngage/SDL_ngagevideo.cpp b/src/video/ngage/SDL_ngagevideo.cpp index 388b65415..1e37e6d6c 100644 --- a/src/video/ngage/SDL_ngagevideo.cpp +++ b/src/video/ngage/SDL_ngagevideo.cpp @@ -150,8 +150,8 @@ int NGAGE_VideoInit(_THIS) /* Use 12-bpp desktop mode */ SDL_zero(mode); mode.format = SDL_PIXELFORMAT_RGB444; - mode.w = 176; - mode.h = 208; + mode.pixel_w = 176; + mode.pixel_h = 208; if (SDL_AddBasicVideoDisplay(&mode) < 0) { return -1; } diff --git a/src/video/offscreen/SDL_offscreenvideo.c b/src/video/offscreen/SDL_offscreenvideo.c index a13477f8a..6d4b01521 100644 --- a/src/video/offscreen/SDL_offscreenvideo.c +++ b/src/video/offscreen/SDL_offscreenvideo.c @@ -103,8 +103,8 @@ int OFFSCREEN_VideoInit(_THIS) /* Use a fake 32-bpp desktop mode */ SDL_zero(mode); mode.format = SDL_PIXELFORMAT_RGB888; - mode.w = 1024; - mode.h = 768; + mode.pixel_w = 1024; + mode.pixel_h = 768; if (SDL_AddBasicVideoDisplay(&mode) < 0) { return -1; } diff --git a/src/video/ps2/SDL_ps2video.c b/src/video/ps2/SDL_ps2video.c index a99357da1..db82b0601 100644 --- a/src/video/ps2/SDL_ps2video.c +++ b/src/video/ps2/SDL_ps2video.c @@ -65,23 +65,17 @@ static int PS2_CreateWindow(_THIS, SDL_Window *window) static int PS2_VideoInit(_THIS) { - SDL_VideoDisplay display; - SDL_DisplayMode current_mode; + SDL_DisplayMode mode; - SDL_zero(current_mode); - current_mode.w = 640; - current_mode.h = 480; - current_mode.refresh_rate = 60.0f; + SDL_zero(mode); + mode.pixel_w = 640; + mode.pixel_h = 480; + mode.refresh_rate = 60.0f; /* 32 bpp for default */ - current_mode.format = SDL_PIXELFORMAT_ABGR8888; + mode.format = SDL_PIXELFORMAT_ABGR8888; - SDL_zero(display); - display.desktop_mode = current_mode; - display.current_mode = current_mode; - SDL_AddDisplayMode(&display, ¤t_mode); - - SDL_AddVideoDisplay(&display, SDL_FALSE); + SDL_AddBasicVideoDisplay(&mode); return 1; } diff --git a/src/video/psp/SDL_pspvideo.c b/src/video/psp/SDL_pspvideo.c index 7ab359ed8..6d55744d1 100644 --- a/src/video/psp/SDL_pspvideo.c +++ b/src/video/psp/SDL_pspvideo.c @@ -137,29 +137,28 @@ VideoBootStrap PSP_bootstrap = { int PSP_VideoInit(_THIS) { SDL_VideoDisplay display; - SDL_DisplayMode current_mode; + SDL_DisplayMode mode; - SDL_zero(current_mode); - current_mode.w = 480; - current_mode.h = 272; - current_mode.refresh_rate = 60.0f; + SDL_zero(mode); + mode.pixel_w = 480; + mode.pixel_h = 272; + mode.refresh_rate = 60.0f; /* 32 bpp for default */ - current_mode.format = SDL_PIXELFORMAT_ABGR8888; + mode.format = SDL_PIXELFORMAT_ABGR8888; SDL_zero(display); - display.desktop_mode = current_mode; - display.current_mode = current_mode; + display.desktop_mode = mode; + display.current_mode = mode; - SDL_AddDisplayMode(&display, ¤t_mode); + SDL_AddDisplayMode(&display, &mode); /* 16 bpp secondary mode */ - current_mode.format = SDL_PIXELFORMAT_BGR565; - display.desktop_mode = current_mode; - display.current_mode = current_mode; - SDL_AddDisplayMode(&display, ¤t_mode); + mode.format = SDL_PIXELFORMAT_BGR565; + SDL_AddDisplayMode(&display, &mode); SDL_AddVideoDisplay(&display, SDL_FALSE); + return 1; } diff --git a/src/video/raspberry/SDL_rpivideo.c b/src/video/raspberry/SDL_rpivideo.c index dbc1a1d28..4859d141a 100644 --- a/src/video/raspberry/SDL_rpivideo.c +++ b/src/video/raspberry/SDL_rpivideo.c @@ -148,7 +148,7 @@ static void AddDispManXDisplay(const int display_id) DISPMANX_MODEINFO_T modeinfo; DISPMANX_DISPLAY_HANDLE_T handle; SDL_VideoDisplay display; - SDL_DisplayMode current_mode; + SDL_DisplayMode mode; SDL_DisplayData *data; handle = vc_dispmanx_display_open(display_id); @@ -162,17 +162,17 @@ static void AddDispManXDisplay(const int display_id) } /* RPI_GetRefreshRate() doesn't distinguish between displays. I'm not sure the hardware distinguishes either */ - SDL_zero(current_mode); - current_mode.w = modeinfo.width; - current_mode.h = modeinfo.height; - current_mode.refresh_rate = RPI_GetRefreshRate(); + SDL_zero(mode); + mode.pixel_w = modeinfo.width; + mode.pixel_h = modeinfo.height; + mode.refresh_rate = RPI_GetRefreshRate(); /* 32 bpp for default */ - current_mode.format = SDL_PIXELFORMAT_ABGR8888; + mode.format = SDL_PIXELFORMAT_ABGR8888; SDL_zero(display); - display.desktop_mode = current_mode; - display.current_mode = current_mode; + display.desktop_mode = mode; + display.current_mode = mode; /* Allocate display internal data */ data = (SDL_DisplayData *)SDL_calloc(1, sizeof(SDL_DisplayData)); diff --git a/src/video/riscos/SDL_riscosmodes.c b/src/video/riscos/SDL_riscosmodes.c index 0988a9451..4b2b7e242 100644 --- a/src/video/riscos/SDL_riscosmodes.c +++ b/src/video/riscos/SDL_riscosmodes.c @@ -137,8 +137,8 @@ static SDL_bool read_mode_block(int *block, SDL_DisplayMode *mode, SDL_bool exte } SDL_zerop(mode); - mode->w = xres; - mode->h = yres; + mode->pixel_w = xres; + mode->pixel_h = yres; mode->format = RISCOS_ModeToPixelFormat(ncolour, modeflags, log2bpp); mode->refresh_rate = (float)rate; diff --git a/src/video/uikit/SDL_uikitmodes.m b/src/video/uikit/SDL_uikitmodes.m index c1a5f8c03..60b555511 100644 --- a/src/video/uikit/SDL_uikitmodes.m +++ b/src/video/uikit/SDL_uikitmodes.m @@ -269,8 +269,8 @@ static int UIKit_AddSingleDisplayMode(SDL_VideoDisplay *display, int w, int h, return -1; } - mode.w = w; - mode.h = h; + mode.pixel_w = w; + mode.pixel_h = h; mode.display_scale = uiscreen.scale; mode.refresh_rate = UIKit_GetDisplayModeRefreshRate(uiscreen); mode.format = SDL_PIXELFORMAT_ABGR8888; @@ -315,8 +315,8 @@ int UIKit_AddDisplay(UIScreen *uiscreen, SDL_bool send_event) } SDL_zero(mode); - mode.w = (int)size.width; - mode.h = (int)size.height; + mode.pixel_w = (int)size.width; + mode.pixel_h = (int)size.height; mode.display_scale = uiscreen.scale; mode.format = SDL_PIXELFORMAT_ABGR8888; mode.refresh_rate = UIKit_GetDisplayModeRefreshRate(uiscreen); @@ -455,11 +455,11 @@ int UIKit_SetDisplayMode(_THIS, SDL_VideoDisplay *display, SDL_DisplayMode *mode /* [UIApplication setStatusBarOrientation:] no longer works reliably * in recent iOS versions, so we can't rotate the screen when setting * the display mode. */ - if (mode->w > mode->h) { + if (mode->pixel_w > mode->pixel_h) { if (!UIKit_IsDisplayLandscape(data.uiscreen)) { return SDL_SetError("Screen orientation does not match display mode size"); } - } else if (mode->w < mode->h) { + } else if (mode->pixel_w < mode->pixel_h) { if (UIKit_IsDisplayLandscape(data.uiscreen)) { return SDL_SetError("Screen orientation does not match display mode size"); } @@ -531,17 +531,23 @@ void SDL_OnApplicationDidChangeStatusBarOrientation() * orientation so that updating a window's fullscreen state to * SDL_WINDOW_FULLSCREEN_DESKTOP keeps the window dimensions in the * correct orientation. */ - if (isLandscape != (desktopmode->w > desktopmode->h)) { - int height = desktopmode->w; - desktopmode->w = desktopmode->h; - desktopmode->h = height; + if (isLandscape != (desktopmode->pixel_w > desktopmode->pixel_h)) { + int height = desktopmode->pixel_w; + desktopmode->pixel_w = desktopmode->pixel_h; + desktopmode->pixel_h = height; + height = desktopmode->screen_w; + desktopmode->screen_w = desktopmode->screen_h; + desktopmode->screen_h = height; } /* Same deal with the current mode + SDL_GetCurrentDisplayMode. */ - if (isLandscape != (currentmode->w > currentmode->h)) { - int height = currentmode->w; - currentmode->w = currentmode->h; - currentmode->h = height; + if (isLandscape != (currentmode->pixel_w > currentmode->pixel_h)) { + int height = currentmode->pixel_w; + currentmode->pixel_w = currentmode->pixel_h; + currentmode->pixel_h = height; + height = currentmode->screen_w; + currentmode->screen_w = currentmode->screen_h; + currentmode->screen_h = height; } switch ([UIApplication sharedApplication].statusBarOrientation) { diff --git a/src/video/uikit/SDL_uikitwindow.m b/src/video/uikit/SDL_uikitwindow.m index eb0abe1a8..1703ba78d 100644 --- a/src/video/uikit/SDL_uikitwindow.m +++ b/src/video/uikit/SDL_uikitwindow.m @@ -177,7 +177,7 @@ int UIKit_CreateWindow(_THIS, SDL_Window *window) const SDL_DisplayMode *bestmode = NULL; for (i = display->num_display_modes; i >= 0; i--) { const SDL_DisplayMode *mode = &display->display_modes[i]; - if ((mode->w >= window->w) && (mode->h >= window->h)) { + if ((mode->screen_w >= window->w) && (mode->screen_h >= window->h)) { bestmode = mode; } } diff --git a/src/video/vita/SDL_vitavideo.c b/src/video/vita/SDL_vitavideo.c index 1d792eec9..cf21ae097 100644 --- a/src/video/vita/SDL_vitavideo.c +++ b/src/video/vita/SDL_vitavideo.c @@ -180,45 +180,41 @@ VideoBootStrap VITA_bootstrap = { /*****************************************************************************/ int VITA_VideoInit(_THIS) { - SDL_VideoDisplay display; - SDL_DisplayMode current_mode; + SDL_DisplayMode mode; #if defined(SDL_VIDEO_VITA_PVR) char *res = SDL_getenv("VITA_RESOLUTION"); #endif - SDL_zero(current_mode); + SDL_zero(mode); #if defined(SDL_VIDEO_VITA_PVR) if (res) { /* 1088i for PSTV (Or Sharpscale) */ if (!SDL_strncmp(res, "1080", 4)) { - current_mode.w = 1920; - current_mode.h = 1088; + mode.pixel_w = 1920; + mode.pixel_h = 1088; } /* 725p for PSTV (Or Sharpscale) */ else if (!SDL_strncmp(res, "720", 3)) { - current_mode.w = 1280; - current_mode.h = 725; + mode.pixel_w = 1280; + mode.pixel_h = 725; } } /* 544p */ else { #endif - current_mode.w = 960; - current_mode.h = 544; + mode.pixel_w = 960; + mode.pixel_h = 544; #if defined(SDL_VIDEO_VITA_PVR) } #endif - current_mode.refresh_rate = 60.0f; + mode.refresh_rate = 60.0f; /* 32 bpp for default */ - current_mode.format = SDL_PIXELFORMAT_ABGR8888; + mode.format = SDL_PIXELFORMAT_ABGR8888; - SDL_zero(display); - display.desktop_mode = current_mode; - display.current_mode = current_mode; + SDL_AddBasicVideoDisplay(&mode); - SDL_AddVideoDisplay(&display, SDL_FALSE); VITA_InitTouch(); VITA_InitKeyboard(); VITA_InitMouse(); diff --git a/src/video/vivante/SDL_vivantevideo.c b/src/video/vivante/SDL_vivantevideo.c index 9178d55cd..fe8ecd63b 100644 --- a/src/video/vivante/SDL_vivantevideo.c +++ b/src/video/vivante/SDL_vivantevideo.c @@ -125,7 +125,7 @@ static int VIVANTE_AddVideoDisplays(_THIS) { SDL_VideoData *videodata = _this->driverdata; SDL_VideoDisplay display; - SDL_DisplayMode current_mode; + SDL_DisplayMode mode; SDL_DisplayData *data; int pitch = 0, bpp = 0; unsigned long pixels = 0; @@ -135,33 +135,33 @@ static int VIVANTE_AddVideoDisplays(_THIS) return SDL_OutOfMemory(); } - SDL_zero(current_mode); + SDL_zero(mode); #if SDL_VIDEO_DRIVER_VIVANTE_VDK data->native_display = vdkGetDisplay(videodata->vdk_private); - vdkGetDisplayInfo(data->native_display, ¤t_mode.w, ¤t_mode.h, &pixels, &pitch, &bpp); + vdkGetDisplayInfo(data->native_display, &mode.pixel_w, &mode.pixel_h, &pixels, &pitch, &bpp); #else data->native_display = videodata->fbGetDisplayByIndex(0); - videodata->fbGetDisplayInfo(data->native_display, ¤t_mode.w, ¤t_mode.h, &pixels, &pitch, &bpp); + videodata->fbGetDisplayInfo(data->native_display, &mode.pixel_w, &mode.pixel_h, &pixels, &pitch, &bpp); #endif /* SDL_VIDEO_DRIVER_VIVANTE_VDK */ switch (bpp) { default: /* Is another format used? */ case 32: - current_mode.format = SDL_PIXELFORMAT_ARGB8888; + mode.format = SDL_PIXELFORMAT_ARGB8888; break; case 16: - current_mode.format = SDL_PIXELFORMAT_RGB565; + mode.format = SDL_PIXELFORMAT_RGB565; break; } /* FIXME: How do we query refresh rate? */ - current_mode.refresh_rate = 60.0f; + mode.refresh_rate = 60.0f; SDL_zero(display); display.name = VIVANTE_GetDisplayName(_this); - display.desktop_mode = current_mode; - display.current_mode = current_mode; + display.desktop_mode = mode; + display.current_mode = mode; display.driverdata = data; SDL_AddVideoDisplay(&display, SDL_FALSE); return 0; diff --git a/src/video/wayland/SDL_waylandvideo.c b/src/video/wayland/SDL_waylandvideo.c index 587b5f049..4ab593966 100644 --- a/src/video/wayland/SDL_waylandvideo.c +++ b/src/video/wayland/SDL_waylandvideo.c @@ -422,17 +422,17 @@ static void AddEmulatedModes(SDL_VideoDisplay *dpy, SDL_bool rot_90) mode.display_scale = 1.0f; if (rot_90) { - mode.w = mode_list[i].h; - mode.h = mode_list[i].w; + mode.pixel_w = mode_list[i].h; + mode.pixel_h = mode_list[i].w; } else { - mode.w = mode_list[i].w; - mode.h = mode_list[i].h; + mode.pixel_w = mode_list[i].w; + mode.pixel_h = mode_list[i].h; } /* Only add modes that are smaller than the native mode. */ - if ((mode.w < native_width && mode.h < native_height) || - (mode.w < native_width && mode.h == native_height) || - (mode.w == native_width && mode.h < native_height)) { + if ((mode.pixel_w < native_width && mode.pixel_h < native_height) || + (mode.pixel_w < native_width && mode.pixel_h == native_height) || + (mode.pixel_w == native_width && mode.pixel_h < native_height)) { SDL_AddDisplayMode(dpy, &mode); } } @@ -565,11 +565,11 @@ static void display_handle_done(void *data, native_mode.format = SDL_PIXELFORMAT_RGB888; if (driverdata->transform & WL_OUTPUT_TRANSFORM_90) { - native_mode.w = driverdata->native_height; - native_mode.h = driverdata->native_width; + native_mode.pixel_w = driverdata->native_height; + native_mode.pixel_h = driverdata->native_width; } else { - native_mode.w = driverdata->native_width; - native_mode.h = driverdata->native_height; + native_mode.pixel_w = driverdata->native_width; + native_mode.pixel_h = driverdata->native_height; } native_mode.display_scale = 1.0f; native_mode.refresh_rate = ((100 * driverdata->refresh) / 1000) / 100.0f; /* mHz to Hz */ @@ -590,11 +590,11 @@ static void display_handle_done(void *data, /* xdg-output dimensions are already transformed, so no need to rotate. */ if (driverdata->has_logical_size || !(driverdata->transform & WL_OUTPUT_TRANSFORM_90)) { - desktop_mode.w = driverdata->width; - desktop_mode.h = driverdata->height; + desktop_mode.pixel_w = driverdata->width; + desktop_mode.pixel_h = driverdata->height; } else { - desktop_mode.w = driverdata->height; - desktop_mode.h = driverdata->width; + desktop_mode.pixel_w = driverdata->height; + desktop_mode.pixel_h = driverdata->width; } desktop_mode.display_scale = driverdata->scale_factor; desktop_mode.refresh_rate = ((100 * driverdata->refresh) / 1000) / 100.0f; /* mHz to Hz */ @@ -976,8 +976,8 @@ static int Wayland_GetDisplayBounds(_THIS, SDL_VideoDisplay *display, SDL_Rect * SDL_WaylandOutputData *driverdata = (SDL_WaylandOutputData *)display->driverdata; rect->x = driverdata->x; rect->y = driverdata->y; - rect->w = display->current_mode.w; - rect->h = display->current_mode.h; + rect->w = display->current_mode.screen_w; + rect->h = display->current_mode.screen_h; return 0; } diff --git a/src/video/windows/SDL_windowsmodes.c b/src/video/windows/SDL_windowsmodes.c index 2bea542e5..f206aa585 100644 --- a/src/video/windows/SDL_windowsmodes.c +++ b/src/video/windows/SDL_windowsmodes.c @@ -38,9 +38,7 @@ static void WIN_UpdateDisplayMode(_THIS, LPCWSTR deviceName, DWORD index, SDL_Di SDL_DisplayModeData *data = (SDL_DisplayModeData *)mode->driverdata; HDC hdc; - data->DeviceMode.dmFields = - (DM_BITSPERPEL | DM_PELSWIDTH | DM_PELSHEIGHT | DM_DISPLAYFREQUENCY | - DM_DISPLAYFLAGS); + data->DeviceMode.dmFields = (DM_BITSPERPEL | DM_PELSWIDTH | DM_PELSHEIGHT | DM_DISPLAYFREQUENCY | DM_DISPLAYFLAGS); /* NOLINTNEXTLINE(bugprone-assignment-in-if-condition): No simple way to extract the assignment */ if (index == ENUM_CURRENT_SETTINGS && (hdc = CreateDC(deviceName, NULL, NULL, NULL)) != NULL) { @@ -180,14 +178,14 @@ static SDL_bool WIN_GetDisplayMode(_THIS, HMONITOR hMonitor, LPCWSTR deviceName, data->DeviceMode = devmode; mode->format = SDL_PIXELFORMAT_UNKNOWN; - mode->w = data->DeviceMode.dmPelsWidth; - mode->h = data->DeviceMode.dmPelsHeight; + mode->pixel_w = data->DeviceMode.dmPelsWidth; + mode->pixel_h = data->DeviceMode.dmPelsHeight; mode->refresh_rate = WIN_GetRefreshRate(&data->DeviceMode); if (index == ENUM_CURRENT_SETTINGS && videodata->GetDpiForMonitor) { UINT hdpi_uint, vdpi_uint; if (videodata->GetDpiForMonitor(hMonitor, MDT_EFFECTIVE_DPI, &hdpi_uint, &vdpi_uint) == S_OK) { - mode->display_scale = (float)hdpi_uint / 96; + mode->display_scale = hdpi_uint / 96.0f; } } diff --git a/src/video/windows/SDL_windowsvideo.c b/src/video/windows/SDL_windowsvideo.c index b3ba89223..43fbc8545 100644 --- a/src/video/windows/SDL_windowsvideo.c +++ b/src/video/windows/SDL_windowsvideo.c @@ -423,19 +423,14 @@ int WIN_VideoInit(_THIS) #if defined(__XBOXONE__) || defined(__XBOXSERIES__) /* For Xbox, we just need to create the single display */ { - SDL_VideoDisplay display; - SDL_DisplayMode current_mode; + SDL_DisplayMode mode; - SDL_zero(current_mode); - D3D12_XBOX_GetResolution(¤t_mode.w, ¤t_mode.h); - current_mode.refresh_rate = 60.0f; - current_mode.format = SDL_PIXELFORMAT_ARGB8888; + SDL_zero(mode); + D3D12_XBOX_GetResolution(&mode.pixel_w, &mode.pixel_h); + mode.refresh_rate = 60.0f; + mode.format = SDL_PIXELFORMAT_ARGB8888; - SDL_zero(display); - display.desktop_mode = current_mode; - display.current_mode = current_mode; - - SDL_AddVideoDisplay(&display, SDL_FALSE); + SDL_AddBasicVideoDisplay(&mode); } #else /*!defined(__XBOXONE__) && !defined(__XBOXSERIES__)*/ if (WIN_InitModes(_this) < 0) { diff --git a/src/video/winrt/SDL_winrtvideo.cpp b/src/video/winrt/SDL_winrtvideo.cpp index fbb12a741..e64c888d0 100644 --- a/src/video/winrt/SDL_winrtvideo.cpp +++ b/src/video/winrt/SDL_winrtvideo.cpp @@ -253,8 +253,8 @@ extern "C" Uint32 D3D11_DXGIFormatToSDLPixelFormat(DXGI_FORMAT dxgiFormat); static void WINRT_DXGIModeToSDLDisplayMode(const DXGI_MODE_DESC *dxgiMode, SDL_DisplayMode *sdlMode) { SDL_zerop(sdlMode); - sdlMode->w = dxgiMode->Width; - sdlMode->h = dxgiMode->Height; + sdlMode->pixel_w = dxgiMode->Width; + sdlMode->pixel_h = dxgiMode->Height; sdlMode->refresh_rate = (((100 * dxgiMode->RefreshRate.Numerator) / dxgiMode->RefreshRate.Denominator) / 100.0f); sdlMode->format = D3D11_DXGIFormatToSDLPixelFormat(dxgiMode->Format); } @@ -303,10 +303,9 @@ static int WINRT_AddDisplaysForOutput(_THIS, IDXGIAdapter1 *dxgiAdapter1, int ou SDL_DisplayMode mode; SDL_zero(mode); display.name = SDL_strdup("Windows Simulator / Terminal Services Display"); - mode.w = (dxgiOutputDesc.DesktopCoordinates.right - dxgiOutputDesc.DesktopCoordinates.left); - mode.h = (dxgiOutputDesc.DesktopCoordinates.bottom - dxgiOutputDesc.DesktopCoordinates.top); + mode.pixel_w = (dxgiOutputDesc.DesktopCoordinates.right - dxgiOutputDesc.DesktopCoordinates.left); + mode.pixel_h = (dxgiOutputDesc.DesktopCoordinates.bottom - dxgiOutputDesc.DesktopCoordinates.top); mode.format = DXGI_FORMAT_B8G8R8A8_UNORM; - mode.refresh_rate = 0.0f; /* Display mode is unknown, so just fill in zero, as specified by SDL's header files */ display.desktop_mode = mode; display.current_mode = mode; if (!SDL_AddDisplayMode(&display, &mode)) { @@ -415,18 +414,23 @@ static int WINRT_AddDisplaysForAdapter(_THIS, IDXGIFactory2 *dxgiFactory2, int a */ #if (NTDDI_VERSION >= NTDDI_WIN10) || (SDL_WINRT_USE_APPLICATIONVIEW && WINAPI_FAMILY == WINAPI_FAMILY_PHONE_APP) - mode.w = WINRT_DIPS_TO_PHYSICAL_PIXELS(appView->VisibleBounds.Width); - mode.h = WINRT_DIPS_TO_PHYSICAL_PIXELS(appView->VisibleBounds.Height); + mode.pixel_w = WINRT_DIPS_TO_PHYSICAL_PIXELS(appView->VisibleBounds.Width); + mode.pixel_h = WINRT_DIPS_TO_PHYSICAL_PIXELS(appView->VisibleBounds.Height); + mode.screen_w = appView->VisibleBounds.Width; + mode.screen_h = appView->VisibleBounds.Height; + mode.display_scale = WINRT_DISPLAY_PROPERTY(LogicalDpi) / 96.0f; #else /* On platform(s) that do not support VisibleBounds, such as Windows 8.1, fall back to CoreWindow's Bounds property. */ - mode.w = WINRT_DIPS_TO_PHYSICAL_PIXELS(coreWin->Bounds.Width); - mode.h = WINRT_DIPS_TO_PHYSICAL_PIXELS(coreWin->Bounds.Height); + mode.pixel_w = WINRT_DIPS_TO_PHYSICAL_PIXELS(coreWin->Bounds.Width); + mode.pixel_h = WINRT_DIPS_TO_PHYSICAL_PIXELS(coreWin->Bounds.Height); + mode.screen_w = coreWin->Bounds.Width; + mode.screen_h = coreWin->Bounds.Height; + mode.display_scale = WINRT_DISPLAY_PROPERTY(LogicalDpi) / 96.0f; #endif mode.format = DXGI_FORMAT_B8G8R8A8_UNORM; - mode.refresh_rate = 0.0f; /* Display mode is unknown, so just fill in zero, as specified by SDL's header files */ display.desktop_mode = mode; display.current_mode = mode; bool error = SDL_AddDisplayMode(&display, &mode) < 0 || @@ -532,7 +536,7 @@ WINRT_DetectWindowFlags(SDL_Window *window) } #endif - if (display->desktop_mode.w != w || display->desktop_mode.h != h) { + if (display->desktop_mode.pixel_w != w || display->desktop_mode.pixel_h != h) { latestFlags |= SDL_WINDOW_MAXIMIZED; } else { latestFlags |= SDL_WINDOW_FULLSCREEN_DESKTOP; @@ -701,12 +705,12 @@ int WINRT_CreateWindow(_THIS, SDL_Window *window) user choice of various things. For now, just adapt the SDL_Window to whatever Windows set-up as the native-window's geometry. */ - window->x = WINRT_DIPS_TO_PHYSICAL_PIXELS(data->coreWindow->Bounds.Left); - window->y = WINRT_DIPS_TO_PHYSICAL_PIXELS(data->coreWindow->Bounds.Top); + window->x = (int)SDL_lroundf(data->coreWindow->Bounds.Left); + window->y = (int)SDL_lroundf(data->coreWindow->Bounds.Top); #if NTDDI_VERSION < NTDDI_WIN10 /* On WinRT 8.x / pre-Win10, just use the size we were given. */ - window->w = WINRT_DIPS_TO_PHYSICAL_PIXELS(data->coreWindow->Bounds.Width); - window->h = WINRT_DIPS_TO_PHYSICAL_PIXELS(data->coreWindow->Bounds.Height); + window->w = (int)SDL_floorf(data->coreWindow->Bounds.Width); + window->h = (int)SDL_floorf(data->coreWindow->Bounds.Height); #else /* On Windows 10, we occasionally get control over window size. For windowed mode apps, try this. @@ -721,8 +725,8 @@ int WINRT_CreateWindow(_THIS, SDL_Window *window) /* We either weren't able to set the window size, or a request for fullscreen was made. Get window-size info from the OS. */ - window->w = WINRT_DIPS_TO_PHYSICAL_PIXELS(data->coreWindow->Bounds.Width); - window->h = WINRT_DIPS_TO_PHYSICAL_PIXELS(data->coreWindow->Bounds.Height); + window->w = (int)SDL_floorf(data->coreWindow->Bounds.Width); + window->h = (int)SDL_floorf(data->coreWindow->Bounds.Height); } #endif diff --git a/src/video/x11/SDL_x11messagebox.c b/src/video/x11/SDL_x11messagebox.c index fc7a0fd07..468e06a97 100644 --- a/src/video/x11/SDL_x11messagebox.c +++ b/src/video/x11/SDL_x11messagebox.c @@ -471,8 +471,8 @@ static int X11_MessageBoxCreateWindow(SDL_MessageBoxDataX11 *data) if ((dev) && (dev->displays) && (dev->num_displays > 0)) { const SDL_VideoDisplay *dpy = &dev->displays[0]; const SDL_DisplayData *dpydata = (SDL_DisplayData *)dpy->driverdata; - x = dpydata->x + ((dpy->current_mode.w - data->dialog_width) / 2); - y = dpydata->y + ((dpy->current_mode.h - data->dialog_height) / 3); + x = dpydata->x + ((dpy->current_mode.pixel_w - data->dialog_width) / 2); + y = dpydata->y + ((dpy->current_mode.pixel_h - data->dialog_height) / 3); } else { /* oh well. This will misposition on a multi-head setup. Init first next time. */ x = (DisplayWidth(display, data->screen) - data->dialog_width) / 2; y = (DisplayHeight(display, data->screen) - data->dialog_height) / 3; diff --git a/src/video/x11/SDL_x11modes.c b/src/video/x11/SDL_x11modes.c index 519e614ab..c1b368a92 100644 --- a/src/video/x11/SDL_x11modes.c +++ b/src/video/x11/SDL_x11modes.c @@ -217,11 +217,11 @@ static SDL_bool SetXRandRModeInfo(Display *display, XRRScreenResources *res, RRC } if (rotation & (XRANDR_ROTATION_LEFT | XRANDR_ROTATION_RIGHT)) { - mode->w = info->height; - mode->h = info->width; + mode->pixel_w = info->height; + mode->pixel_h = info->width; } else { - mode->w = info->width; - mode->h = info->height; + mode->pixel_w = info->width; + mode->pixel_h = info->height; } mode->refresh_rate = CalculateXRandRRefreshRate(info); ((SDL_DisplayModeData *)mode->driverdata)->xrandr_mode = modeID; @@ -343,8 +343,8 @@ static int X11_AddXRandRDisplay(_THIS, Display *dpy, int screen, RROutput output SDL_zero(mode); modeID = crtc->mode; - mode.w = crtc->width; - mode.h = crtc->height; + mode.pixel_w = crtc->width; + mode.pixel_h = crtc->height; mode.format = pixelformat; display_x = crtc->x; @@ -369,9 +369,9 @@ static int X11_AddXRandRDisplay(_THIS, Display *dpy, int screen, RROutput output displaydata->screen = screen; displaydata->visual = vinfo.visual; displaydata->depth = vinfo.depth; - displaydata->hdpi = display_mm_width ? (((float)mode.w) * 25.4f / display_mm_width) : 0.0f; - displaydata->vdpi = display_mm_height ? (((float)mode.h) * 25.4f / display_mm_height) : 0.0f; - displaydata->ddpi = SDL_ComputeDiagonalDPI(mode.w, mode.h, ((float)display_mm_width) / 25.4f, ((float)display_mm_height) / 25.4f); + displaydata->hdpi = display_mm_width ? (((float)mode.pixel_w) * 25.4f / display_mm_width) : 0.0f; + displaydata->vdpi = display_mm_height ? (((float)mode.pixel_h) * 25.4f / display_mm_height) : 0.0f; + displaydata->ddpi = SDL_ComputeDiagonalDPI(mode.pixel_w, mode.pixel_h, ((float)display_mm_width) / 25.4f, ((float)display_mm_height) / 25.4f); displaydata->scanline_pad = scanline_pad; displaydata->x = display_x; displaydata->y = display_y; @@ -574,8 +574,8 @@ static int X11_InitModes_StdXlib(_THIS) } SDL_zero(mode); - mode.w = WidthOfScreen(screen); - mode.h = HeightOfScreen(screen); + mode.pixel_w = WidthOfScreen(screen); + mode.pixel_h = HeightOfScreen(screen); mode.format = pixelformat; displaydata = (SDL_DisplayData *)SDL_calloc(1, sizeof(*displaydata)); @@ -596,9 +596,9 @@ static int X11_InitModes_StdXlib(_THIS) displaydata->screen = default_screen; displaydata->visual = vinfo.visual; displaydata->depth = vinfo.depth; - displaydata->hdpi = display_mm_width ? (((float)mode.w) * 25.4f / display_mm_width) : 0.0f; - displaydata->vdpi = display_mm_height ? (((float)mode.h) * 25.4f / display_mm_height) : 0.0f; - displaydata->ddpi = SDL_ComputeDiagonalDPI(mode.w, mode.h, ((float)display_mm_width) / 25.4f, ((float)display_mm_height) / 25.4f); + displaydata->hdpi = display_mm_width ? (((float)mode.pixel_w) * 25.4f / display_mm_width) : 0.0f; + displaydata->vdpi = display_mm_height ? (((float)mode.pixel_h) * 25.4f / display_mm_height) : 0.0f; + displaydata->ddpi = SDL_ComputeDiagonalDPI(mode.pixel_w, mode.pixel_h, ((float)display_mm_width) / 25.4f, ((float)display_mm_height) / 25.4f); xft_dpi = GetXftDPI(dpy); if (xft_dpi > 0) { @@ -783,8 +783,8 @@ int X11_SetDisplayMode(_THIS, SDL_VideoDisplay *sdl_display, SDL_DisplayMode *mo goto ungrabServer; } - mm_width = mode->w * DisplayWidthMM(display, data->screen) / DisplayWidth(display, data->screen); - mm_height = mode->h * DisplayHeightMM(display, data->screen) / DisplayHeight(display, data->screen); + mm_width = mode->pixel_w * DisplayWidthMM(display, data->screen) / DisplayWidth(display, data->screen); + mm_height = mode->pixel_h * DisplayHeightMM(display, data->screen) / DisplayHeight(display, data->screen); /* !!! FIXME: this can get into a problem scenario when a window is bigger than a physical monitor in a configuration where one screen @@ -795,7 +795,7 @@ int X11_SetDisplayMode(_THIS, SDL_VideoDisplay *sdl_display, SDL_DisplayMode *mo crashing */ X11_XSync(display, False); PreXRRSetScreenSizeErrorHandler = X11_XSetErrorHandler(SDL_XRRSetScreenSizeErrHandler); - X11_XRRSetScreenSize(display, RootWindow(display, data->screen), mode->w, mode->h, mm_width, mm_height); + X11_XRRSetScreenSize(display, RootWindow(display, data->screen), mode->pixel_w, mode->pixel_h, mm_width, mm_height); X11_XSync(display, False); X11_XSetErrorHandler(PreXRRSetScreenSizeErrorHandler); @@ -831,8 +831,8 @@ int X11_GetDisplayBounds(_THIS, SDL_VideoDisplay *sdl_display, SDL_Rect *rect) rect->x = data->x; rect->y = data->y; - rect->w = sdl_display->current_mode.w; - rect->h = sdl_display->current_mode.h; + rect->w = sdl_display->current_mode.screen_w; + rect->h = sdl_display->current_mode.screen_h; return 0; } diff --git a/test/testautomation_video.c b/test/testautomation_video.c index 1e0244916..6ad3de1c3 100644 --- a/test/testautomation_video.c +++ b/test/testautomation_video.c @@ -425,8 +425,9 @@ int video_getClosestDisplayModeCurrentResolution(void *arg) } /* Set the desired resolution equals to current resolution */ - target.w = current.w; - target.h = current.h; + SDL_zero(target); + target.pixel_w = current.pixel_w; + target.pixel_h = current.pixel_h; for (variation = 0; variation < 8; variation++) { /* Vary constraints on other query parameters */ target.format = (variation & 1) ? current.format : 0; @@ -439,11 +440,11 @@ int video_getClosestDisplayModeCurrentResolution(void *arg) SDLTest_Assert(dResult != NULL, "Verify returned value is not NULL"); /* Check that one gets the current resolution back again */ - SDLTest_AssertCheck(closest.w == current.w, "Verify returned width matches current width; expected: %d, got: %d", current.w, closest.w); - SDLTest_AssertCheck(closest.h == current.h, "Verify returned height matches current height; expected: %d, got: %d", current.h, closest.h); + SDLTest_AssertCheck(closest.pixel_w == current.pixel_w, "Verify returned width matches current width; expected: %d, got: %d", current.pixel_w, closest.pixel_w); + SDLTest_AssertCheck(closest.pixel_h == current.pixel_h, "Verify returned height matches current height; expected: %d, got: %d", current.pixel_h, closest.pixel_h); /* NOLINTBEGIN(clang-analyzer-core.NullDereference): Checked earlier for NULL */ - SDLTest_AssertCheck(closest.w == dResult->w, "Verify return value matches assigned value; expected: %d, got: %d", closest.w, dResult->w); - SDLTest_AssertCheck(closest.h == dResult->h, "Verify return value matches assigned value; expected: %d, got: %d", closest.h, dResult->h); + SDLTest_AssertCheck(closest.pixel_w == dResult->pixel_w, "Verify return value matches assigned value; expected: %d, got: %d", closest.pixel_w, dResult->pixel_w); + SDLTest_AssertCheck(closest.pixel_h == dResult->pixel_h, "Verify return value matches assigned value; expected: %d, got: %d", closest.pixel_h, dResult->pixel_h); /* NOLINTEND(clang-analyzer-core.NullDereference) */ } } @@ -473,11 +474,11 @@ int video_getClosestDisplayModeRandomResolution(void *arg) for (variation = 0; variation < 16; variation++) { /* Set random constraints */ - target.w = (variation & 1) ? SDLTest_RandomIntegerInRange(1, 4096) : 0; - target.h = (variation & 2) ? SDLTest_RandomIntegerInRange(1, 4096) : 0; + SDL_zero(target); + target.pixel_w = (variation & 1) ? SDLTest_RandomIntegerInRange(1, 4096) : 0; + target.pixel_h = (variation & 2) ? SDLTest_RandomIntegerInRange(1, 4096) : 0; target.format = (variation & 4) ? SDLTest_RandomIntegerInRange(1, 10) : 0; target.refresh_rate = (variation & 8) ? (float)SDLTest_RandomIntegerInRange(25, 120) : 0.0f; - target.driverdata = 0; /* Make call; may or may not find anything, so don't validate any further */ SDL_GetClosestDisplayMode(i, &target, &closest); @@ -501,8 +502,8 @@ int video_getWindowDisplayMode(void *arg) int result; /* Invalidate part of the mode content so we can check values later */ - mode.w = -1; - mode.h = -1; + mode.pixel_w = -1; + mode.pixel_h = -1; mode.refresh_rate = -1.0f; /* Call against new test window */ @@ -511,8 +512,8 @@ int video_getWindowDisplayMode(void *arg) result = SDL_GetWindowDisplayMode(window, &mode); SDLTest_AssertPass("Call to SDL_GetWindowDisplayMode()"); SDLTest_AssertCheck(result == 0, "Validate result value; expected: 0, got: %d", result); - SDLTest_AssertCheck(mode.w > 0, "Validate mode.w content; expected: >0, got: %d", mode.w); - SDLTest_AssertCheck(mode.h > 0, "Validate mode.h content; expected: >0, got: %d", mode.h); + SDLTest_AssertCheck(mode.pixel_w > 0, "Validate mode.w content; expected: >0, got: %d", mode.pixel_w); + SDLTest_AssertCheck(mode.pixel_h > 0, "Validate mode.h content; expected: >0, got: %d", mode.pixel_h); SDLTest_AssertCheck(mode.refresh_rate > 0.0f, "Validate mode.refresh_rate content; expected: >0, got: %g", mode.refresh_rate); } diff --git a/test/testdisplayinfo.c b/test/testdisplayinfo.c index 7cfa8cc2b..5b10aa4f3 100644 --- a/test/testdisplayinfo.c +++ b/test/testdisplayinfo.c @@ -24,9 +24,9 @@ print_mode(const char *prefix, const SDL_DisplayMode *mode) return; } - SDL_Log("%s: fmt=%s w=%d h=%d refresh=%gHz\n", + SDL_Log("%s: fmt=%s w=%d h=%d scale=%d%% refresh=%gHz\n", prefix, SDL_GetPixelFormatName(mode->format), - mode->w, mode->h, mode->refresh_rate); + mode->pixel_w, mode->pixel_h, (int)(mode->display_scale * 100.0f), mode->refresh_rate); } int main(int argc, char *argv[]) diff --git a/test/testwm.c b/test/testwm.c index fb9dfe247..15dff183c 100644 --- a/test/testwm.c +++ b/test/testwm.c @@ -108,7 +108,7 @@ draw_modes_menu(SDL_Window *window, SDL_Renderer *renderer, SDL_FRect viewport) } (void)SDL_snprintf(text, sizeof text, "%d: %dx%d@%gHz", - i, mode.w, mode.h, mode.refresh_rate); + i, mode.pixel_w, mode.pixel_h, mode.refresh_rate); /* Update column width */ text_length = (int)SDL_strlen(text);