Question regarding SDL3 High Pixel Density w/ OpenGL

direct · May 8, 2024, 3:57pm

Hello! I hope this type of question is alright here.

I am migrating my application to SDL3 and am running into an inconsistency on macOS vs Windows which is puzzling me.

In SDL2 I was using these hints to enable high pixel density on Windows:

SDL_SetHint(SDL_HINT_WINDOWS_DPI_AWARENESS, "permonitorv2");
SDL_SetHint(SDL_HINT_WINDOWS_DPI_SCALING, "1");

These appear to have been removed in SDL3 (although when I scan through the source it seems I can still set the DPI_AWARENESS hint using the string literal associated).

Regardless, I am seeing a discrepancy between macOS and Windows where on Windows no matter if I set the HIGH_PIXEL_DENSITY window flag, my framebuffer remains at the size of the window.

If anyone has any insight here, am I missing something obvious?

Here is my example source:

#include <iostream>
#include <SDL.h>

int main() {
    SDL_SetHint("SDL_WINDOWS_DPI_AWARENESS", "permonitorv2");

    SDL_Init(SDL_INIT_VIDEO);

    SDL_Window* window = SDL_CreateWindow("Test", 500, 500, SDL_WINDOW_HIGH_PIXEL_DENSITY | SDL_WINDOW_OPENGL);
    SDL_GL_SetAttribute(SDL_GL_CONTEXT_MAJOR_VERSION, 3);
    SDL_GL_SetAttribute(SDL_GL_CONTEXT_MINOR_VERSION, 3);
    SDL_GLContext context = SDL_GL_CreateContext(window);
    SDL_GL_SetSwapInterval(1);
    SDL_Event event;


    bool should_quit = false;
    while (!should_quit) {
        while (SDL_PollEvent(&event)) {
            if (event.type == SDL_EVENT_QUIT)
                should_quit = true;
        }
        int w, h;
        SDL_GetWindowSize(window, &w, &h);
        printf("Window size: %d x %d\n", w, h);

        SDL_GetWindowSizeInPixels(window, &w, &h);
        printf("Window size in pixels: %d x %d\n", w, h);

        float scale = SDL_GetWindowDisplayScale(window);
        printf("Window display scale: %f\n", scale);

        float pixel_density = SDL_GetWindowPixelDensity(window);
        printf("Window pixel density: %f\n", pixel_density);

        SDL_GL_SwapWindow(window);
    }

    SDL_DestroyWindow(window);
    SDL_GL_DeleteContext(context);
    SDL_Quit();
}

Output on macOS in Retina mode:

Window size: 500 x 500
Window size in pixels: 1000 x 1000
Window display scale: 2.000000
Window pixel density: 2.000000

Output on Windows at 1.5x display scaling:

Window size: 500 x 500
Window size in pixels: 500 x 500
Window display scale: 1.500000
Window pixel density: 1.000000

Am I meant to handle this manually inside of my program?

Thanks.

slouken · May 8, 2024, 4:23pm

Check this out and please let us know if it’s not clear:

github.com

libsdl-org/SDL/blob/main/docs/README-highdpi.md


SDL 3.0 has new support for high DPI displays

Displays now have a content display scale, which is the expected scale for content based on the DPI settings of the display. For example, a 4K display might have a 2.0 (200%) display scale, which means that the user expects UI elements to be twice as big on this display, to aid in readability. You can query the display content scale using `SDL_GetDisplayContentScale()`, and when this changes you get an `SDL_EVENT_WINDOW_DISPLAY_SCALE_CHANGED` event.

The window size is now distinct from the window pixel size, and the ratio between the two is the window pixel density. If the window is created with the `SDL_WINDOW_HIGH_PIXEL_DENSITY` flag, SDL will try to match the native pixel density for the display, otherwise it will try to have the pixel size match the window size. You can query the window pixel density using `SDL_GetWindowPixelDensity()`. You can query the window pixel size using `SDL_GetWindowSizeInPixels()`, and when this changes you get an `SDL_EVENT_WINDOW_PIXEL_SIZE_CHANGED` event. You are guaranteed to get a `SDL_EVENT_WINDOW_PIXEL_SIZE_CHANGED` event when a window is created and resized, and you can use this event to create and resize your graphics context for the window.

The window has a display scale, which is the scale from the pixel resolution to the desired content size, e.g. the combination of the pixel density and the content scale. For example, a 3840x2160 window displayed at 200% on Windows, and a 1920x1080 window with the high density flag on a 2x display on macOS will both have a pixel size of 3840x2160 and a display scale of 2.0.  You can query the window display scale using `SDL_GetWindowDisplayScale()`, and when this changes you get an `SDL_EVENT_WINDOW_DISPLAY_SCALE_CHANGED` event.

Mathias · May 10, 2024, 6:48am

I tried the example with Linux Mint Cinnamon and experimentally set the scaling to 200%.
This gives me the following output:

Window size: 500 x 500
Window size in pixels: 500 x 500
Window display scale: 1.000000
Window pixel density: 1.000000

direct · May 10, 2024, 1:54pm

Thanks. I read through that prior to posting, but I guess not closely enough.

I think where I misunderstood was that I assumed the SDL_GetWindowSize() would return the effective size that I should be using in my renderer (in points rather than pixels), but I see now I will have to do the conversion myself based on the information returned from the various functions. Thanks.