GPU Display: Render also text in X11 and GLFW at correct size taking into accound HiDPI settings

Author: davidrohr

GPU/GPUTracking/display/frontend/GPUDisplayFrontendGlfw.cxx

@@ -227,11 +227,17 @@ void GPUDisplayFrontendGlfw::scroll_callback(GLFWwindow* window, double x, doubl
 
 void GPUDisplayFrontendGlfw::cursorPos_callback(GLFWwindow* window, double x, double y)
 {
-  me->mMouseMvX = x;
-  me->mMouseMvY = y;
+  me->mMouseMvX = x * me->mPixelRatio; // Window coordinates to framebuffer pixels
+  me->mMouseMvY = y * me->mPixelRatio;
 }
 
-void GPUDisplayFrontendGlfw::resize_callback(GLFWwindow* window, int32_t width, int32_t height) { me->ResizeScene(width, height); }
+void GPUDisplayFrontendGlfw::resize_callback(GLFWwindow* window, int32_t width, int32_t height) // Framebuffer size in pixels
+{
+  int32_t windowWidth, windowHeight;
+  glfwGetWindowSize(window, &windowWidth, &windowHeight);
+  me->mPixelRatio = windowWidth ? (double)width / windowWidth : 1.;
+  me->ResizeScene(width, height);
+}
 
 void GPUDisplayFrontendGlfw::focus_callback(GLFWwindow* window, int32_t focused)
 {
@@ -240,7 +246,22 @@ void GPUDisplayFrontendGlfw::focus_callback(GLFWwindow* window, int32_t focused)
   }
 }
 
-void GPUDisplayFrontendGlfw::maximize_callback(GLFWwindow* window, int32_t maximized) { me->setWindowState(glfwGetWindowMonitor(window) != nullptr, maximized); }
+void GPUDisplayFrontendGlfw::contentScale_callback(GLFWwindow* window, float xscale, float yscale)
+{
+  me->mScale = xscale;
+}
+
+void GPUDisplayFrontendGlfw::maximize_callback(GLFWwindow* window, int32_t maximized)
+{
+  me->setWindowState(glfwGetWindowMonitor(window) != nullptr, maximized);
+  if (glfwGetPlatform() == GLFW_PLATFORM_WAYLAND) { // Called before the resize. GLFW keeps the maximized size if the compositor leaves the size to the client when unmaximizing, so restore the last windowed size
+    if (maximized) {
+      glfwGetWindowSize(window, &me->mWindowedWidth, &me->mWindowedHeight);
+    } else {
+      me->mRestoreWindowedSize = true; // Must be applied after GLFW has processed the configure event, otherwise GLFW resizes to the pending maximized size again
+    }
+  }
+}
 
 #ifndef GPUCA_STANDALONE
 void GPUDisplayFrontendGlfw::DisplayLoop()
@@ -273,6 +294,7 @@ int32_t GPUDisplayFrontendGlfw::FrontendMain()
     glfwWindowHint(GLFW_OPENGL_FORWARD_COMPAT, 0);
     glfwWindowHint(GLFW_OPENGL_PROFILE, mBackend->CoreProfile() ? GLFW_OPENGL_CORE_PROFILE : GLFW_OPENGL_COMPAT_PROFILE);
   }
+  glfwWindowHint(GLFW_SCALE_TO_MONITOR, GLFW_TRUE); // Initial size scaled by the content scale on X11 / Win32
   mWindow = glfwCreateWindow(INIT_WIDTH, INIT_HEIGHT, DISPLAY_WINDOW_NAME, nullptr, nullptr);
   if (!mWindow) {
     fprintf(stderr, "Error creating glfw window\n");
@@ -288,10 +310,19 @@ int32_t GPUDisplayFrontendGlfw::FrontendMain()
   glfwSetMouseButtonCallback(mWindow, mouseButton_callback);
   glfwSetScrollCallback(mWindow, scroll_callback);
   glfwSetCursorPosCallback(mWindow, cursorPos_callback);
-  glfwSetWindowSizeCallback(mWindow, resize_callback);
+  glfwSetFramebufferSizeCallback(mWindow, resize_callback);
   glfwSetWindowMaximizeCallback(mWindow, maximize_callback);
   glfwSetWindowFocusCallback(mWindow, focus_callback);
-  glfwSetWindowSizeLimits(mWindow, MIN_WIDTH, MIN_HEIGHT, GLFW_DONT_CARE, GLFW_DONT_CARE);
+  float xscale, yscale;
+  glfwGetWindowContentScale(mWindow, &xscale, &yscale);
+  contentScale_callback(mWindow, xscale, yscale);
+  glfwSetWindowContentScaleCallback(mWindow, contentScale_callback);
+  const float limitScale = (glfwGetPlatform() == GLFW_PLATFORM_X11 || glfwGetPlatform() == GLFW_PLATFORM_WIN32) ? mScale : 1.f; // Window coordinates are pixels on X11 / Win32, logical on Wayland / macOS
+  glfwSetWindowSizeLimits(mWindow, MIN_WIDTH * limitScale, MIN_HEIGHT * limitScale, GLFW_DONT_CARE, GLFW_DONT_CARE);
+  int32_t fbWidth, fbHeight, windowWidth, windowHeight;
+  glfwGetFramebufferSize(mWindow, &fbWidth, &fbHeight);
+  glfwGetWindowSize(mWindow, &windowWidth, &windowHeight);
+  mPixelRatio = windowWidth ? (double)fbWidth / windowWidth : 1.; // Updated in resize_callback, which must not be called before InitDisplay
   applyInitialWindowState();
   if (backend()->backendType() == GPUDisplayBackend::TYPE_OPENGL) {
     glfwSwapInterval(1);
@@ -322,6 +353,12 @@ int32_t GPUDisplayFrontendGlfw::FrontendMain()
     }
     waitForFPSLimit();
     glfwPollEvents();
+    if (mRestoreWindowedSize) {
+      mRestoreWindowedSize = false;
+      if (mWindowedWidth > 0 && mWindowedHeight > 0 && !glfwGetWindowAttrib(mWindow, GLFW_MAXIMIZED)) {
+        glfwSetWindowSize(mWindow, mWindowedWidth, mWindowedHeight);
+      }
+    }
   }
 
   ExitDisplay();

GPU/GPUTracking/display/frontend/GPUDisplayFrontendGlfw.h

@@ -35,6 +35,7 @@ class GPUDisplayFrontendGlfw : public GPUDisplayFrontend
   void OpenGLPrint(const char* s, float x, float y, float r, float g, float b, float a, bool fromBotton = true) override;
   bool EnableSendKey() override;
   void getSize(int32_t& width, int32_t& height) override;
+  float getDisplayScale() const override { return mScale; }
   int32_t getVulkanSurface(void* instance, void* surface) override;
   uint32_t getReqVulkanExtensions(const char**& p) override;
 
@@ -51,10 +52,16 @@ class GPUDisplayFrontendGlfw : public GPUDisplayFrontend
   static void resize_callback(GLFWwindow* mWindow, int32_t width, int32_t height);
   static void maximize_callback(GLFWwindow* mWindow, int32_t maximized);
   static void focus_callback(GLFWwindow* mWindow, int32_t focused);
+  static void contentScale_callback(GLFWwindow* mWindow, float xscale, float yscale);
   static int32_t GetKey(int32_t key);
   static void GetKey(int32_t keyin, int32_t scancode, int32_t mods, int32_t& keyOut, int32_t& keyPressOut);
 
   GLFWwindow* mWindow;
+  float mScale = 1.f;         // Content scale for text / UI
+  int32_t mWindowedWidth = 0; // Window size before maximizing (Wayland)
+  int32_t mWindowedHeight = 0;
+  bool mRestoreWindowedSize = false;
+  double mPixelRatio = 1.; // Framebuffer pixels per window coordinate (1 on X11 / Win32, scale on Wayland / macOS)
 
   pthread_mutex_t mSemLockExit = PTHREAD_MUTEX_INITIALIZER;
   int32_t mWindowX = 0;

GPU/GPUTracking/display/frontend/GPUDisplayFrontendX11.cxx

@@ -24,6 +24,7 @@
 
 #include <unistd.h>
 #include <X11/Xatom.h>
+#include <X11/Xresource.h>
 
 #ifdef GPUCA_BUILD_EVENT_DISPLAY_VULKAN
 #include <vulkan/vulkan.h>
@@ -202,6 +203,19 @@ int32_t GPUDisplayFrontendX11::FrontendMain()
     return (-1);
   }
 
+  XrmInitialize();
+  if (const char* resources = XResourceManagerString(mXDisplay)) {
+    XrmDatabase db = XrmGetStringDatabase(resources);
+    char* type = nullptr;
+    XrmValue value;
+    if (db && XrmGetResource(db, "Xft.dpi", "Xft.Dpi", &type, &value) && value.addr && atof(value.addr) > 0) {
+      mScale = atof(value.addr) / 96.;
+    }
+    if (db) {
+      XrmDestroyDatabase(db);
+    }
+  }
+
   // Make sure OpenGL's GLX extension supported
   if (!glXQueryExtension(mXDisplay, &errorBase, &eventBase)) {
     GPUError("X server has no OpenGL GLX extension");
@@ -264,13 +278,13 @@ int32_t GPUDisplayFrontendX11::FrontendMain()
   windowAttributes.event_mask = ExposureMask | VisibilityChangeMask | KeyPressMask | KeyReleaseMask | ButtonPressMask | ButtonReleaseMask | PointerMotionMask | StructureNotifyMask | SubstructureNotifyMask | FocusChangeMask | PropertyChangeMask;
 
   // Create an X window with the selected visual
-  mWindow = XCreateWindow(mXDisplay, win, 50, 50, INIT_WIDTH, INIT_HEIGHT, // Position / Width and height of window
+  mWindow = XCreateWindow(mXDisplay, win, 50, 50, INIT_WIDTH * mScale, INIT_HEIGHT * mScale, // Position / Width and height of window
                           0, visualInfo->depth, InputOutput, visualInfo->visual, CWBorderPixel | CWColormap | CWEventMask, &windowAttributes);
   XSetStandardProperties(mXDisplay, mWindow, DISPLAY_WINDOW_NAME, DISPLAY_WINDOW_NAME, None, nullptr, 0, nullptr);
   XSizeHints sizeHints{};
   sizeHints.flags = PMinSize;
-  sizeHints.min_width = MIN_WIDTH;
-  sizeHints.min_height = MIN_HEIGHT;
+  sizeHints.min_width = MIN_WIDTH * mScale;
+  sizeHints.min_height = MIN_HEIGHT * mScale;
   XSetWMNormalHints(mXDisplay, mWindow, &sizeHints);
   if (backend()->backendType() == GPUDisplayBackend::TYPE_OPENGL) {
     glXMakeCurrent(mXDisplay, mWindow, glxContext);

GPU/GPUTracking/display/frontend/GPUDisplayFrontendX11.h

@@ -36,6 +36,7 @@ class GPUDisplayFrontendX11 : public GPUDisplayFrontend
   void SetVSync(bool enable) override;
   void OpenGLPrint(const char* s, float x, float y, float r, float g, float b, float a, bool fromBotton = true) override;
   void getSize(int32_t& width, int32_t& height) override;
+  float getDisplayScale() const override { return mScale; }
   int32_t getVulkanSurface(void* instance, void* surface) override;
   uint32_t getReqVulkanExtensions(const char**& p) override;
 
@@ -51,6 +52,7 @@ class GPUDisplayFrontendX11 : public GPUDisplayFrontend
   Display* mXDisplay = nullptr;
   Window mWindow;
   void updateWindowState();
+  float mScale = 1.f; // From the Xft.dpi X resource (desktop scaling, e.g. KDE with "Apply scaling themselves" for X11 apps)
 
   PFNGLXSWAPINTERVALEXTPROC mGlXSwapIntervalEXT = nullptr;
   bool vsync_supported = false;