Windows highdpi2

include/SDL_hints.h

@@ -1121,6 +1121,26 @@ extern "C" {
  */
 #define SDL_HINT_RENDER_DIRECT3D11_DEBUG    "SDL_RENDER_DIRECT3D11_DEBUG"
 
+ /**
+ *  \brief If set to 1, then allow high-DPI on all windows.
+ *
+ * If high-DPI is allowed, the framebuffer size (which can be queried by calling SDL_GL_GetDrawableSize,
+ * and returns a size in pixels) is decoupled from the SDL window size. SDL window sizes are in
+ * points, which are translated to pixels by multiplying by the scale factor of the monitor that
+ * the window is on.
+ *
+ * If high-DPI is not enabled with this hint, the framebuffer size will be equal to the window size
+ * returned by SDL_GetWindowSize, but the OS will scale up the framebuffer if the window is on a
+ * high-DPI monitor.
+ *
+ * An SDL_WINDOWEVENT_RESIZED event will be sent to the application when the framebuffer size changes,
+ * which could happen in response to the window moving to a monitor with a different scale factor
+ * (either from the user moving it, or SDL_SetWindowPosition), or the monitor's scale factor changing.
+ *
+ * High-DPI support is currently implemented on macOS and Windows.
+ */
+#define SDL_HINT_VIDEO_ALLOW_HIGHDPI "SDL_VIDEO_ALLOW_HIGHDPI"
+
 /**
  *  \brief  A variable controlling whether the Direct3D device is initialized for thread-safe operations.
  *

include/SDL_video.h

@@ -116,7 +116,8 @@ typedef enum
     SDL_WINDOW_FOREIGN = 0x00000800,            /**< window not created by SDL */
     SDL_WINDOW_ALLOW_HIGHDPI = 0x00002000,      /**< window should be created in high-DPI mode if supported.
                                                      On macOS NSHighResolutionCapable must be set true in the
-                                                     application's Info.plist for this to have any effect. */
+                                                     application's Info.plist for this to have any effect. 
+                                                     (deprecated, use SDL_HINT_VIDEO_ALLOW_HIGHDPI) */
     SDL_WINDOW_MOUSE_CAPTURE    = 0x00004000,   /**< window has mouse captured (unrelated to MOUSE_GRABBED) */
     SDL_WINDOW_ALWAYS_ON_TOP    = 0x00008000,   /**< window should always be above others */
     SDL_WINDOW_SKIP_TASKBAR     = 0x00010000,   /**< window should not be added to the taskbar */

src/render/direct3d/SDL_render_d3d.c

@@ -300,8 +300,7 @@ D3D_ActivateRenderer(SDL_Renderer * renderer)
         SDL_Window *window = renderer->window;
         int w, h;
         Uint32 window_flags = SDL_GetWindowFlags(window);
-
-        SDL_GetWindowSize(window, &w, &h);
+        WIN_GetDrawableSize(window, &w, &h);
         data->pparams.BackBufferWidth = w;
         data->pparams.BackBufferHeight = h;
         if (window_flags & SDL_WINDOW_FULLSCREEN && (window_flags & SDL_WINDOW_FULLSCREEN_DESKTOP) != SDL_WINDOW_FULLSCREEN_DESKTOP) {
@@ -344,9 +343,17 @@ D3D_WindowEvent(SDL_Renderer * renderer, const SDL_WindowEvent *event)
 
     if (event->event == SDL_WINDOWEVENT_SIZE_CHANGED) {
         data->updateSize = SDL_TRUE;
+        D3D_ActivateRenderer(renderer);
     }
 }
 
+static int
+D3D_GetOutputSize(SDL_Renderer * renderer, int *w, int *h)
+{
+    WIN_GetDrawableSize(renderer->window, w, h);
+    return 0;
+}
+
 static D3DBLEND GetBlendFunc(SDL_BlendFactor factor)
 {
     switch (factor) {
@@ -1571,6 +1578,7 @@ D3D_CreateRenderer(SDL_Window * window, Uint32 flags)
     }
 
     renderer->WindowEvent = D3D_WindowEvent;
+    renderer->GetOutputSize = D3D_GetOutputSize;
     renderer->SupportsBlendMode = D3D_SupportsBlendMode;
     renderer->CreateTexture = D3D_CreateTexture;
     renderer->UpdateTexture = D3D_UpdateTexture;
@@ -1600,7 +1608,7 @@ D3D_CreateRenderer(SDL_Window * window, Uint32 flags)
     SDL_GetWindowWMInfo(window, &windowinfo);
 
     window_flags = SDL_GetWindowFlags(window);
-    SDL_GetWindowSize(window, &w, &h);
+    WIN_GetDrawableSize(window, &w, &h);
     SDL_GetWindowDisplayMode(window, &fullscreen_mode);
 
     SDL_zero(pparams);

src/render/direct3d11/SDL_render_d3d11.c

@@ -27,6 +27,7 @@
 
 #define COBJMACROS
 #include "../../core/windows/SDL_windows.h"
+#include "../../video/windows/SDL_windowswindow.h"
 #include "SDL_hints.h"
 #include "SDL_loadso.h"
 #include "SDL_syswm.h"
@@ -910,7 +911,7 @@ D3D11_CreateWindowSizeDependentResources(SDL_Renderer * renderer)
     /* The width and height of the swap chain must be based on the display's
      * non-rotated size.
      */
-    SDL_GetWindowSize(renderer->window, &w, &h);
+    WIN_GetDrawableSize(renderer->window, &w, &h);
     data->rotation = D3D11_GetCurrentRotation();
     /* SDL_Log("%s: windowSize={%d,%d}, orientation=%d\n", __FUNCTION__, w, h, (int)data->rotation); */
     if (D3D11_IsDisplayRotated90Degrees(data->rotation)) {
@@ -1041,6 +1042,13 @@ D3D11_WindowEvent(SDL_Renderer * renderer, const SDL_WindowEvent *event)
     }
 }
 
+static int
+D3D11_GetOutputSize(SDL_Renderer * renderer, int *w, int *h)
+{
+    WIN_GetDrawableSize(renderer->window, w, h);
+    return 0;
+}
+
 static SDL_bool
 D3D11_SupportsBlendMode(SDL_Renderer * renderer, SDL_BlendMode blendMode)
 {
@@ -2353,6 +2361,7 @@ D3D11_CreateRenderer(SDL_Window * window, Uint32 flags)
     data->identity = MatrixIdentity();
 
     renderer->WindowEvent = D3D11_WindowEvent;
+    renderer->GetOutputSize = D3D11_GetOutputSize;
     renderer->SupportsBlendMode = D3D11_SupportsBlendMode;
     renderer->CreateTexture = D3D11_CreateTexture;
     renderer->UpdateTexture = D3D11_UpdateTexture;

src/test/SDL_test_common.c

@@ -244,7 +244,7 @@ SDLTest_CommonArg(SDLTest_CommonState * state, int index)
         return 1;
     }
     if (SDL_strcasecmp(argv[index], "--allow-highdpi") == 0) {
-        state->window_flags |= SDL_WINDOW_ALLOW_HIGHDPI;
+        SDL_SetHint(SDL_HINT_VIDEO_ALLOW_HIGHDPI, "1");
         return 1;
     }
     if (SDL_strcasecmp(argv[index], "--windows") == 0) {

src/video/SDL_video.c

@@ -1517,6 +1517,11 @@ SDL_CreateWindow(const char *title, int x, int y, int w, int h, Uint32 flags)
         }
     }
 
+    /* This hint adds SDL_WINDOW_ALLOW_HIGHDPI to all windows. */
+    if (SDL_GetHintBoolean(SDL_HINT_VIDEO_ALLOW_HIGHDPI, SDL_FALSE)) {
+        flags |= SDL_WINDOW_ALLOW_HIGHDPI;
+    }
+
     if (flags & SDL_WINDOW_VULKAN) {
         if (!_this->Vulkan_CreateSurface) {
             SDL_SetError("Vulkan support is either not configured in SDL "

src/video/windows/SDL_windowsevents.c

@@ -33,6 +33,7 @@
 #include "../../events/SDL_touch_c.h"
 #include "../../events/scancodes_windows.h"
 #include "SDL_hints.h"
+#include "SDL_log.h"
 
 /* Dropfile support */
 #include <shellapi.h>
@@ -51,6 +52,8 @@
 #include "wmmsg.h"
 #endif
 
+#define HIGHDPI_DEBUG
+
 /* Masks for processing the windows KEYDOWN and KEYUP messages */
 #define REPEATED_KEYMASK    (1<<30)
 #define EXTENDED_KEYMASK    (1<<24)
@@ -85,6 +88,12 @@
 #ifndef WM_UNICHAR
 #define WM_UNICHAR 0x0109
 #endif
+#ifndef WM_DPICHANGED
+#define WM_DPICHANGED 0x02E0
+#endif
+#ifndef WM_GETDPISCALEDSIZE
+#define WM_GETDPISCALEDSIZE 0x02E4
+#endif
 
 #ifndef IS_HIGH_SURROGATE
 #define IS_HIGH_SURROGATE(x)   (((x) >= 0xd800) && ((x) <= 0xdbff))
@@ -733,7 +742,12 @@ WIN_WindowProc(HWND hwnd, UINT msg, WPARAM wParam, LPARAM lParam)
                 /* Only generate mouse events for real mouse */
                 if (GetMouseMessageSource() != SDL_MOUSE_EVENT_SOURCE_TOUCH &&
                     lParam != data->last_pointer_update) {
-                    SDL_SendMouseMotion(data->window, 0, 0, GET_X_LPARAM(lParam), GET_Y_LPARAM(lParam));
+                    int x = GET_X_LPARAM(lParam);
+                    int y = GET_Y_LPARAM(lParam);
+
+                    WIN_ClientPointToSDL(data->window, &x, &y);
+
+                    SDL_SendMouseMotion(data->window, 0, 0, x, y);
                 }
             }
         }
@@ -1052,6 +1066,12 @@ WIN_WindowProc(HWND hwnd, UINT msg, WPARAM wParam, LPARAM lParam)
             SDL_GetWindowMinimumSize(data->window, &min_w, &min_h);
             SDL_GetWindowMaximumSize(data->window, &max_w, &max_h);
 
+            /* Convert w, h, min_w, min_h, max_w, max_h to unscaled.
+               We can treat them as a point in the client area. */
+            WIN_ClientPointFromSDL(data->window, &w, &h);
+            WIN_ClientPointFromSDL(data->window, &min_w, &min_h);
+            WIN_ClientPointFromSDL(data->window, &max_w, &max_h);
+
             /* Store in min_w and min_h difference between current size and minimal
                size so we don't need to call AdjustWindowRectEx twice */
             min_w -= w;
@@ -1077,7 +1097,11 @@ WIN_WindowProc(HWND hwnd, UINT msg, WPARAM wParam, LPARAM lParam)
                 size.bottom = h;
                 size.right = w;
 
-                AdjustWindowRectEx(&size, style, menu, 0);
+                if (data->videodata->highdpi_enabled && data->videodata->AdjustWindowRectExForDpi) {
+                    data->videodata->AdjustWindowRectExForDpi(&size, style, menu, 0, data->scaling_dpi);
+                } else {
+                    AdjustWindowRectEx(&size, style, menu, 0);
+                }
                 w = size.right - size.left;
                 h = size.bottom - size.top;
             }
@@ -1141,12 +1165,25 @@ WIN_WindowProc(HWND hwnd, UINT msg, WPARAM wParam, LPARAM lParam)
 
             x = rect.left;
             y = rect.top;
+            WIN_ScreenPointToSDL(&x, &y);
+
             SDL_SendWindowEvent(data->window, SDL_WINDOWEVENT_MOVED, x, y);
 
+            /* NOTE: important to convert w/h from SDL (points) to Windows (pixels) using 
+               WIN_ClientPointToSDL, which uses the window's actual
+               DPI value. */
             w = rect.right - rect.left;
             h = rect.bottom - rect.top;
+            WIN_ClientPointToSDL(data->window, &w, &h);
+
             SDL_SendWindowEvent(data->window, SDL_WINDOWEVENT_RESIZED, w, h);
 
+#ifdef HIGHDPI_DEBUG
+            SDL_Log("WM_WINDOWPOSCHANGED: Windows client rect (pixels): (%d, %d) (%d x %d)\tSDL client rect (points): (%d, %d) (%d x %d) cached dpi %d, windows reported dpi %d",
+                rect.left, rect.top, rect.right - rect.left, rect.bottom - rect.top,
+                x, y, w, h, data->scaling_dpi, data->videodata->GetDpiForWindow ? data->videodata->GetDpiForWindow(data->hwnd) : 0);
+#endif
+
             /* Forces a WM_PAINT event */
             InvalidateRect(hwnd, NULL, FALSE);
 
@@ -1364,7 +1401,10 @@ WIN_WindowProc(HWND hwnd, UINT msg, WPARAM wParam, LPARAM lParam)
             if (window->hit_test) {
                 POINT winpoint = { GET_X_LPARAM(lParam), GET_Y_LPARAM(lParam) };
                 if (ScreenToClient(hwnd, &winpoint)) {
-                    const SDL_Point point = { (int) winpoint.x, (int) winpoint.y };
+                    int x = (int) winpoint.x;
+                    int y = (int) winpoint.y;
+                    WIN_ClientPointToSDL(data->window, &x, &y);
+                    const SDL_Point point = { x, y };
                     const SDL_HitTestResult rc = window->hit_test(window, &point, window->hit_test_data);
                     switch (rc) {
                         #define POST_HIT_TEST(ret) { SDL_SendWindowEvent(data->window, SDL_WINDOWEVENT_HIT_TEST, 0, 0); return ret; }
@@ -1385,6 +1425,127 @@ WIN_WindowProc(HWND hwnd, UINT msg, WPARAM wParam, LPARAM lParam)
             }
         }
         break;
+
+    case WM_GETDPISCALEDSIZE: /* Windows 10 Creators Update+ */
+        /* GetDpiForWindow and AdjustWindowRectExForDpi will be present, but check anyway. */
+        if (data->videodata->highdpi_enabled 
+            && data->videodata->GetDpiForWindow
+            && data->videodata->AdjustWindowRectExForDpi) {
+
+            /*
+            Windows expects applications to scale their window rects linearly
+            when dragging between monitors with different DPI's.
+            e.g. a 100x100 window dragged to a 200% scaled monitor
+            becomes 200x200.
+
+            For SDL, we instead want the client size to scale linearly.
+            This is not the same as the window rect scaling linearly,
+            because Windows doesn't scale the non-client area (titlebar etc.)
+            linearly. So, we need to handle this message to request custom
+            scaling.
+            */
+
+            const int nextDPI = (int)wParam;
+            const int prevDPI = (int)data->videodata->GetDpiForWindow(hwnd);
+            SIZE *sizeInOut = (SIZE *)lParam;
+
+            int frame_w, frame_h;
+            int query_client_w_win, query_client_h_win;
+
+#ifdef HIGHDPI_DEBUG
+            SDL_Log("WM_GETDPISCALEDSIZE: current DPI: %d potential DPI: %d. input size: (%dx%d)", prevDPI, nextDPI, sizeInOut->cx, sizeInOut->cy);
+#endif
+
+            /* subtract the window frame size that would have been used at prevDPI */
+            {
+                DWORD style = GetWindowLong(hwnd, GWL_STYLE);
+                BOOL menu = (style & WS_CHILDWINDOW) ? FALSE : (GetMenu(hwnd) != NULL);
+                RECT rect = {0};
+
+                if (!(data->window->flags & SDL_WINDOW_BORDERLESS))
+                    data->videodata->AdjustWindowRectExForDpi(&rect, style, menu, 0, prevDPI);
+
+                frame_w = -rect.left + rect.right;
+                frame_h = -rect.top + rect.bottom;
+
+                query_client_w_win = sizeInOut->cx - frame_w;
+                query_client_h_win = sizeInOut->cy - frame_h;
+            }
+
+            /* convert to new dpi */
+            query_client_w_win = MulDiv(query_client_w_win, nextDPI, prevDPI);
+            query_client_h_win = MulDiv(query_client_h_win, nextDPI, prevDPI);
+
+            /* add the window frame size that would be used at nextDPI */
+            {
+                DWORD style = GetWindowLong(hwnd, GWL_STYLE);
+                BOOL menu = (style & WS_CHILDWINDOW) ? FALSE : (GetMenu(hwnd) != NULL);
+                RECT rect;
+
+                rect.left = 0;
+                rect.top = 0;
+                rect.right = query_client_w_win;
+                rect.bottom = query_client_h_win;
+
+                if (!(data->window->flags & SDL_WINDOW_BORDERLESS))
+                    data->videodata->AdjustWindowRectExForDpi(&rect, style, menu, 0, nextDPI);
+
+                /* This is supposed to control the suggested rect param of WM_DPICHANGED */
+                sizeInOut->cx = rect.right - rect.left;
+                sizeInOut->cy = rect.bottom - rect.top;
+            }
+
+#ifdef HIGHDPI_DEBUG
+            SDL_Log("WM_GETDPISCALEDSIZE: output size: (%dx%d)", sizeInOut->cx, sizeInOut->cy);
+#endif
+            return TRUE;
+        }
+        break;
+
+    case WM_DPICHANGED: /* Windows 8.1+ */
+        if (data->videodata->highdpi_enabled) {
+            const int newDPI = HIWORD(wParam);
+            RECT* const suggestedRect = (RECT*)lParam;
+            int w, h;
+
+#ifdef HIGHDPI_DEBUG
+            SDL_Log("WM_DPICHANGED: %d to %d\tsuggested rect: (%d, %d), (%dx%d)\n", 
+                data->scaling_dpi, newDPI,
+                suggestedRect->left, suggestedRect->top, suggestedRect->right - suggestedRect->left, suggestedRect->bottom - suggestedRect->top);
+#endif
+
+            /* update the cached DPI value for this window */
+            data->scaling_dpi = newDPI;
+
+            /*
+            DPI_AWARENESS_CONTEXT_PER_MONITOR_AWARE_V2 means that
+            WM_GETDPISCALEDSIZE will have been called, so we can use suggestedRect.
+            */
+            w = suggestedRect->right - suggestedRect->left;
+            h = suggestedRect->bottom - suggestedRect->top;
+
+#ifdef HIGHDPI_DEBUG
+            SDL_Log("WM_DPICHANGED: current SDL window size: (%dx%d)\tcalling SetWindowPos: (%d, %d), (%dx%d)\n",
+                data->window->w, data->window->h,
+                suggestedRect->left, suggestedRect->top, w, h);
+#endif
+
+            /* clear the window size, to cause us to send a SDL_WINDOWEVENT_RESIZED event in WM_WINDOWPOSCHANGED */
+            data->window->w = 0;
+            data->window->h = 0;
+
+            data->expected_resize = SDL_TRUE;
+            SetWindowPos(hwnd,
+                NULL,
+                suggestedRect->left,
+                suggestedRect->top,
+                w,
+                h,
+                SWP_NOZORDER | SWP_NOACTIVATE);
+            data->expected_resize = SDL_FALSE;
+            return 0;
+        }
+        break;
     }
 
     /* If there's a window proc, assume it's going to handle messages */