Track window physical size instead of logical size for dynamic dpi scaling

Author: floppyhammer

pathfinder/gpu/gl/window_builder.cpp

@@ -28,7 +28,7 @@ bool is_extension_supported(const char *name) {
 }
 
 #ifndef __ANDROID__
-WindowBuilderGl::WindowBuilderGl(const Vec2I &size) {
+WindowBuilderGl::WindowBuilderGl(const Vec2I &logical_size) {
     glfwInit();
 
     // Major GL version.
@@ -48,16 +48,19 @@ WindowBuilderGl::WindowBuilderGl(const Vec2I &size) {
     #endif
 
     float dpi_scaling_factor;
-    auto glfw_window = glfw_window_init(size, PRIMARY_WINDOW_TITLE, dpi_scaling_factor, false, nullptr);
+    auto glfw_window = glfw_window_init(logical_size, PRIMARY_WINDOW_TITLE, dpi_scaling_factor, false, nullptr);
 
-    primary_window_ = std::make_shared<WindowGl>(size, glfw_window);
+    auto physical_size = (logical_size.to_f32() * dpi_scaling_factor).to_i32();
+
+    primary_window_ = std::make_shared<WindowGl>(physical_size, glfw_window);
     primary_window_->set_dpi_scaling_factor(dpi_scaling_factor);
 
     // Set user data.
     primary_window_->window_index = 0;
 
     std::ostringstream ss;
-    ss << "Window created:\n  Size: " << size << "\n  DPI Scaling: " << dpi_scaling_factor;
+    ss << "Window created:\n  Physical Size: " << physical_size << "\n  Logical Size: " << logical_size
+       << "\n  DPI Scaling: " << dpi_scaling_factor;
     Logger::info(ss.str());
 
     // Have to make the window context current before calling gladLoadGL().

pathfinder/gpu/gl/window_builder.h

@@ -14,12 +14,12 @@ class WindowBuilderGl : public WindowBuilder {
 #ifdef __ANDROID__
     WindowBuilderGl(ANativeWindow *native_window, const Vec2I &window_size);
 #else
-    explicit WindowBuilderGl(const Vec2I &size);
+    explicit WindowBuilderGl(const Vec2I &logical_size);
 #endif
 
     ~WindowBuilderGl() override;
 
-    uint8_t create_window(const Vec2I &size, const std::string &title) override;
+    uint8_t create_window(const Vec2I &logical_size, const std::string &title) override;
 
     std::shared_ptr<Device> request_device() override;
 

pathfinder/gpu/vk/window.cpp

@@ -49,7 +49,7 @@ VkExtent2D WindowVk::choose_swap_extent(const VkSurfaceCapabilitiesKHR& capabili
 std::shared_ptr<SwapChain> WindowVk::get_swap_chain(const std::shared_ptr<Device>& device) {
     if (!swapchain_) {
         auto device_vk = static_cast<DeviceVk*>(device.get());
-        swapchain_ = std::make_shared<SwapChainVk>(logical_size_, this, device_vk);
+        swapchain_ = std::make_shared<SwapChainVk>(get_physical_size(), this, device_vk);
     }
 
     return swapchain_;

pathfinder/gpu/vk/window_builder.cpp

@@ -29,7 +29,7 @@ void destroy_debug_utils_messenger_ext(VkInstance instance,
 }
 
 #ifndef __ANDROID__
-WindowBuilderVk::WindowBuilderVk(const Vec2I &size) {
+WindowBuilderVk::WindowBuilderVk(const Vec2I &logical_size) {
     glfwInit();
 
     // To not create an OpenGL context (as we're using Vulkan).
@@ -40,18 +40,20 @@ WindowBuilderVk::WindowBuilderVk(const Vec2I &size) {
     setup_debug_messenger();
 
     float dpi_scaling_factor;
-    auto glfw_window = glfw_window_init(size, PRIMARY_WINDOW_TITLE, dpi_scaling_factor, false, nullptr);
+    auto glfw_window = glfw_window_init(logical_size, PRIMARY_WINDOW_TITLE, dpi_scaling_factor, false, nullptr);
+
+    auto physical_size = (logical_size.to_f32() * dpi_scaling_factor).to_i32();
 
     VkSurfaceKHR surface{};
     VK_CHECK_RESULT(glfwCreateWindowSurface(instance_, glfw_window, nullptr, &surface))
 
     initialize_after_surface_creation(surface);
 
-    primary_window_ = std::make_shared<WindowVk>(size, glfw_window, surface, instance_);
+    primary_window_ = std::make_shared<WindowVk>(physical_size, glfw_window, surface, instance_);
     primary_window_->set_dpi_scaling_factor(dpi_scaling_factor);
 }
 #else
-WindowBuilderVk::WindowBuilderVk(ANativeWindow *native_window, const Vec2I &window_size) {
+WindowBuilderVk::WindowBuilderVk(ANativeWindow *native_window, const Vec2I &physical_size) {
     native_window_ = native_window;
 
     create_instance();
@@ -68,7 +70,7 @@ WindowBuilderVk::WindowBuilderVk(ANativeWindow *native_window, const Vec2I &wind
 
     initialize_after_surface_creation(surface);
 
-    primary_window_ = std::make_shared<WindowVk>(window_size, surface, instance_);
+    primary_window_ = std::make_shared<WindowVk>(physical_size, surface, instance_);
 }
 #endif
 

pathfinder/gpu/vk/window_builder.h

@@ -54,9 +54,9 @@ class Window;
 class WindowBuilderVk : public WindowBuilder {
 public:
 #ifndef __ANDROID__
-    explicit WindowBuilderVk(const Vec2I &size);
+    explicit WindowBuilderVk(const Vec2I &logical_size);
 #else
-    explicit WindowBuilderVk(ANativeWindow *native_window, const Vec2I &window_size);
+    explicit WindowBuilderVk(ANativeWindow *native_window, const Vec2I &physical_size);
 #endif
 
     ~WindowBuilderVk() override;

pathfinder/gpu/window.cpp

@@ -5,21 +5,21 @@
 namespace Pathfinder {
 
 #ifdef __ANDROID__
-Window::Window(const Vec2I& size) : logical_size_(size) {}
+Window::Window(const Vec2I& size) : physical_size_(size) {}
 #else
-Window::Window(const Vec2I& size, GLFWwindow* window_handle) : logical_size_(size), glfw_window_(window_handle) {
+Window::Window(const Vec2I& size, GLFWwindow* window_handle) : physical_size_(size), glfw_window_(window_handle) {
     // Assign this to window user, so we can fetch it when window size changes.
     glfwSetWindowUserPointer(glfw_window_, this);
     glfwSetFramebufferSizeCallback(glfw_window_, framebuffer_resize_callback);
 }
 #endif
 
 Vec2I Window::get_physical_size() const {
-    return (logical_size_.to_f32() * dpi_scaling_factor_).to_i32();
+    return physical_size_;
 }
 
 Vec2I Window::get_logical_size() const {
-    return logical_size_;
+    return (physical_size_.to_f32() / dpi_scaling_factor_).to_i32();
 }
 
 Vec2I Window::get_position() const {
@@ -48,7 +48,7 @@ void Window::set_dpi_scaling_factor(float scale) {
 
 #ifndef __ANDROID__
 void Window::framebuffer_resize_callback(GLFWwindow* glfw_window, int width, int height) {
-    auto window = reinterpret_cast<Window*>(glfwGetWindowUserPointer(glfw_window));
+    auto window = static_cast<Window*>(glfwGetWindowUserPointer(glfw_window));
 
     if (window) {
         // Get the size of window decorations.
@@ -57,11 +57,11 @@ void Window::framebuffer_resize_callback(GLFWwindow* glfw_window, int width, int
 
         // TODO: consider window decorations.
         window->just_resized_ = true;
-        window->logical_size_ = (Vec2F(width, height) / window->get_dpi_scaling_factor()).to_i32();
-        window->minimized_ = window->logical_size_.area() == 0;
+        window->physical_size_ = Vec2I(width, height);
+        window->minimized_ = window->physical_size_.area() == 0;
 
-        Logger::info("Window resized to physical" + Vec2I(width, height).to_string() + ", logical" +
-                     window->logical_size_.to_string());
+        Logger::info("Window resized to physical" + window->get_physical_size().to_string() + ", logical" +
+                     window->get_logical_size().to_string());
     } else {
         Logger::error("glfwGetWindowUserPointer is NULL!");
     }

pathfinder/gpu/window.h

@@ -59,7 +59,7 @@ class Window {
     uint8_t window_index{};
 
 protected:
-    Vec2I logical_size_;
+    Vec2I physical_size_;
 
     bool just_resized_ = false;
     bool fullscreen_ = false;

pathfinder/gpu/window_builder.cpp

@@ -57,6 +57,10 @@ float WindowBuilder::get_dpi_scaling_factor(uint8_t window_index) const {
     return get_window(window_index).lock()->get_dpi_scaling_factor();
 }
 
+void WindowBuilder::set_dpi_scaling_factor(uint8_t window_index, float new_scale) {
+    get_window(window_index).lock()->set_dpi_scaling_factor(new_scale);
+}
+
 void WindowBuilder::poll_events() {
     // Reset window flags.
     {
@@ -81,35 +85,30 @@ void WindowBuilder::set_fullscreen(bool fullscreen) {
     primary_window_->fullscreen_ = fullscreen;
 
     if (fullscreen) {
-        reserved_window_logical_size_ = primary_window_->get_logical_size();
+        reserved_window_physical_size_ = primary_window_->get_physical_size();
         reserved_window_position_ = primary_window_->get_position();
 
         const GLFWvidmode *mode = glfwGetVideoMode(glfwGetPrimaryMonitor());
 
-        auto physical_size = Vec2I(mode->width, mode->height);
-
         glfwSetWindowMonitor(primary_window_->glfw_window_,
                              glfwGetPrimaryMonitor(),
                              0,
                              0,
-                             physical_size.x,
-                             physical_size.y,
+                             mode->width,
+                             mode->height,
                              GLFW_DONT_CARE);
 
-        auto logical_size = (physical_size.to_f32() / get_dpi_scaling_factor(0)).to_i32();
-        primary_window_->logical_size_ = logical_size;
+        primary_window_->physical_size_ = Vec2I(mode->width, mode->height);
     } else {
-        auto physical_size = (reserved_window_logical_size_.to_f32() * get_dpi_scaling_factor(0)).to_i32();
-
         glfwSetWindowMonitor(primary_window_->glfw_window_,
-                             NULL,
+                             nullptr,
                              reserved_window_position_.x,
                              reserved_window_position_.y,
-                             physical_size.x,
-                             physical_size.y,
+                             reserved_window_physical_size_.x,
+                             reserved_window_physical_size_.y,
                              GLFW_DONT_CARE);
 
-        primary_window_->logical_size_ = reserved_window_logical_size_;
+        primary_window_->physical_size_ = reserved_window_physical_size_;
     }
 #endif
 }

pathfinder/gpu/window_builder.h

@@ -31,10 +31,12 @@ class WindowBuilder {
     /// Create a new sub-window.
     virtual uint8_t create_window(const Vec2I &size, const std::string &title) = 0;
 
-    [[nodiscard]] std::weak_ptr<Window> get_window(uint8_t window_index) const;
+    std::weak_ptr<Window> get_window(uint8_t window_index) const;
 
     float get_dpi_scaling_factor(uint8_t window_index) const;
 
+    void set_dpi_scaling_factor(uint8_t window_index, float new_scale);
+
     virtual std::shared_ptr<Device> request_device() = 0;
 
     virtual std::shared_ptr<Queue> create_queue() = 0;
@@ -60,7 +62,7 @@ class WindowBuilder {
     bool primary_window_fullscreen_ = false;
 
     // Size before going fullscreen or being minimized.
-    Vec2I reserved_window_logical_size_;
+    Vec2I reserved_window_physical_size_;
 
     Vec2I reserved_window_position_;
 };