Method updateWindowSize

src/visualizer/window/window_manager.cpp:399–455

    }

    void WindowManager::updateWindowSize(const char* const reason, const ResizeIntent intent) {
        if (!window_) {
            return;
        }

        int winW, winH, fbW, fbH;
        SDL_GetWindowSize(window_, &winW, &winH);
        SDL_GetWindowSizeInPixels(window_, &fbW, &fbH);
        const glm::ivec2 next_window_size(winW, winH);
        const glm::ivec2 next_framebuffer_size(fbW, fbH);
        const bool window_size_changed = next_window_size != window_size_;
        const bool framebuffer_size_changed = next_framebuffer_size != framebuffer_size_;
        const bool size_changed = window_size_changed || framebuffer_size_changed;

        const auto flags = SDL_GetWindowFlags(window_);
        if (size_changed) {
            last_window_size_change_time_ = std::chrono::steady_clock::now();
            LOG_DEBUG("Window size update [{}]: logical {}x{} -> {}x{}, framebuffer {}x{} -> {}x{}, fullscreen={}, flags=0x{:x}",
                      reason,
                      window_size_.x,
                      window_size_.y,
                      next_window_size.x,
                      next_window_size.y,
                      framebuffer_size_.x,
                      framebuffer_size_.y,
                      next_framebuffer_size.x,
                      next_framebuffer_size.y,
                      is_fullscreen_,
                      static_cast<unsigned>(flags));
        } else {
            LOG_DEBUG("Window size update [{}]: unchanged logical {}x{}, framebuffer {}x{}, fullscreen={}, flags=0x{:x}",
                      reason,
                      next_window_size.x,
                      next_window_size.y,
                      next_framebuffer_size.x,
                      next_framebuffer_size.y,
                      is_fullscreen_,
                      static_cast<unsigned>(flags));
        }

        window_size_ = next_window_size;
        framebuffer_size_ = next_framebuffer_size;
        if (vulkan_context_ && framebuffer_size_changed) {
            const ResizeIntent effective_intent =
                intent == ResizeIntent::Interactive && (is_fullscreen_ || isMaximized())
                    ? ResizeIntent::Exact
                    : intent;
            const auto vulkan_resize_intent =
                effective_intent == ResizeIntent::Interactive
                    ? VulkanContext::ResizeIntent::Interactive
                    : VulkanContext::ResizeIntent::Exact;
            vulkan_context_->notifyFramebufferResized(fbW, fbH, vulkan_resize_intent);
        }
        if (size_changed) {
            lfs::core::events::ui::WindowResized{.width = fbW, .height = fbH}.emit();
        }
    }