Window improvements.

Added handling for content scaling changes to update UI.
Refactored Window constructed in windowed mode to begin in the middle of the screen at half its size.
Fixed bad state sync for size and position via set_size and set_position by adding on_x_callback.

Author: MStachowicz

source/Application.hpp

@@ -194,7 +194,7 @@ int main(int argc, char* argv[])
 		Platform::Core::initialise_directories();
 		Platform::Core::initialise_GLFW();
 		Platform::Input input   = Platform::Input();
-		Platform::Window window = Platform::Window(1920, 1080, input);
+		Platform::Window window = Platform::Window(glm::vec2{0.5f, 0.5f}, input);
 		Platform::Core::initialise_OpenGL();
 		OpenGL::DebugRenderer::init();
 		Platform::Core::initialise_ImGui(window);

source/Platform/Core.cpp

@@ -111,13 +111,14 @@ namespace Platform
 	{
 		IMGUI_CHECKVERSION();
 		ImGui::CreateContext();
-		ImGuiIO& io = ImGui::GetIO();
-		(void)io;
-		io.ConfigFlags |= ImGuiConfigFlags_DockingEnable; // Enable docking
 		ImGui_ImplGlfw_InitForOpenGL(p_window.m_handle, true);
 		ImGui_ImplOpenGL3_Init(Config::GLSL_Version_String);
-		glm::uvec2 size = p_window.size();
-		io.DisplaySize = ImVec2(static_cast<float>(size.x), static_cast<float>(size.y));
+
+		ImGuiIO& io        = ImGui::GetIO();
+		io.FontGlobalScale = p_window.get_content_scale();
+		glm::uvec2 size    = p_window.size();
+		io.DisplaySize     = ImVec2(static_cast<float>(size.x), static_cast<float>(size.y));
+		io.ConfigFlags    |= ImGuiConfigFlags_DockingEnable;
 
 		LOG("[INIT] Initialised ImGui");
 	}

source/Platform/Window.cpp

@@ -21,13 +21,13 @@
 
 namespace Platform
 {
-	Window::Window(const int& p_width, const int& p_height, Input& p_input_state) noexcept
+	Window::Window(const glm::vec2& p_screen_factor, Input& p_input_state) noexcept
 		: m_size_fullscreen{get_max_resolution()}
-		, m_position_fullscreen{0, 0}
-		, m_size_windowed{p_width, p_height}
-		, m_position_windowed{0, get_window_title_bar_height()} // Offset starting position by height of title bar.
+		, m_position_fullscreen{0, 0} // init in body
+		, m_size_windowed{0, 0}       // init in body
+		, m_position_windowed{0, 0}   // init in body
 		, m_fullscreen{false}
-		, m_aspect_ratio{m_fullscreen ? static_cast<float>(m_size_fullscreen.x) / static_cast<float>(m_size_fullscreen.y) : static_cast<float>(m_size_windowed.x) / static_cast<float>(m_size_windowed.y)}
+		, m_aspect_ratio{0.f}
 		, m_VSync{true}
 		, m_close_requested{false}
 		, m_handle{nullptr}
@@ -36,23 +36,37 @@ namespace Platform
 	{
 		glfwWindowHint(GLFW_RESIZABLE, GL_TRUE);
 		glfwWindowHint(GLFW_SCALE_TO_MONITOR, GLFW_TRUE);
-		const auto window_size = size();
-		const auto window_position = position();
-		m_handle = glfwCreateWindow(window_size.x, window_size.y, Config::Is_Debug ? "Spirit - Debug" : "Spirit", m_fullscreen ? glfwGetPrimaryMonitor() : NULL, NULL);
+		auto monitor = glfwGetPrimaryMonitor();
+
+		int wa_xpos, wa_ypos, wa_width, wa_height;
+		glfwGetMonitorWorkarea(monitor, &wa_xpos, &wa_ypos, &wa_width, &wa_height);
+		m_size_windowed     = {(unsigned int)(wa_width * p_screen_factor.x), (unsigned int)(wa_height * p_screen_factor.y)};
+		m_position_windowed = {wa_xpos + (wa_width - m_size_windowed.x) / 2, wa_ypos + (wa_height - m_size_windowed.y) / 2};
+
+		if (m_fullscreen)
+			m_handle = glfwCreateWindow(m_size_fullscreen.x, m_size_fullscreen.y, Config::Is_Debug ? "Spirit - Debug" : "Spirit", m_fullscreen ? monitor : NULL, NULL);
+		else
+		{
+			m_handle = glfwCreateWindow(m_size_windowed.x, m_size_windowed.y, Config::Is_Debug ? "Spirit - Debug" : "Spirit", NULL, NULL);
+			glfwSetWindowPos(m_handle, m_position_windowed.x, m_position_windowed.y);
+		}
+
+		auto set_size = size();
+		m_aspect_ratio = static_cast<float>(set_size.x) / static_cast<float>(set_size.y);
+
 		ASSERT(m_handle != nullptr, "[WINDOW] Failed to construct Window");
 
 		glfwMakeContextCurrent(m_handle); // Set this window as the context for GL render calls.
-		glfwSetWindowPos(m_handle, window_position.x, window_position.y);
-		glfwSetWindowSize(m_handle, window_size.x, window_size.y); // glfwCreateWindow size requests are not hard constraints. Have to ensure size was set by calling glfwSetWindowSize.
 		set_VSync(m_VSync);
 
 		{ // Set the GLFW callbacks.
 			// GLFW is a C library requiring static || global functions for callbacks.
 			// We use the glfwSetWindowUserPointer and glfwGetWindowUserPointer to retrieve this instance of Window from the library and call the member functions.
 			glfwSetWindowUserPointer(m_handle, this);
-			glfwSetWindowCloseCallback(m_handle, [](GLFWwindow* p_handle){((Window*)glfwGetWindowUserPointer(p_handle))->request_close();});
-			glfwSetWindowSizeCallback(m_handle,  [](GLFWwindow* p_handle, int p_size_x, int p_size_y){((Window*)glfwGetWindowUserPointer(p_handle))->set_size({p_size_x, p_size_y});});
-			glfwSetWindowPosCallback(m_handle,   [](GLFWwindow* p_handle, int p_pos_x, int p_pos_y){((Window*)glfwGetWindowUserPointer(p_handle))->set_position({p_pos_x, p_pos_y});});
+			glfwSetWindowCloseCallback(m_handle,        [](GLFWwindow* p_handle){((Window*)glfwGetWindowUserPointer(p_handle))->request_close();});
+			glfwSetWindowSizeCallback(m_handle,         [](GLFWwindow* p_handle, int p_size_x, int p_size_y){((Window*)glfwGetWindowUserPointer(p_handle))->on_size_callback({p_size_x, p_size_y});});
+			glfwSetWindowPosCallback(m_handle,          [](GLFWwindow* p_handle, int p_pos_x, int p_pos_y){((Window*)glfwGetWindowUserPointer(p_handle))->on_position_callback({p_pos_x, p_pos_y});});
+			glfwSetWindowContentScaleCallback(m_handle, [](GLFWwindow* p_handle, float p_scale_x, float p_scale_y){((Window*)glfwGetWindowUserPointer(p_handle))->on_content_scale_callback((p_scale_x + p_scale_y) * 0.5f);});
 
 			{ // INPUT CALLBACKS - Because we only have access to the WindowUserPointer via GLFW, we have to access the Input and set it from the window.
 				glfwSetKeyCallback(m_handle,         [](GLFWwindow* p_handle, int p_key, int p_scancode, int p_action, int p_mode){((Window*)glfwGetWindowUserPointer(p_handle))->m_input.glfw_key_press(p_key, p_scancode, p_action, p_mode);});
@@ -76,6 +90,8 @@ namespace Platform
 			icon.height = icon_image.height;
 			glfwSetWindowIcon(m_handle, 1, &icon);
 		}
+
+		ASSERT(m_aspect_ratio != 0.f, "[WINDOW] Aspect ratio badly initialised");
 		LOG("[WINDOW] Created Window with resolution {}x{}", size().x, size().y);
 	}
 	Window::~Window() noexcept
@@ -85,13 +101,12 @@ namespace Platform
 		LOG("[WINDOW] Closed window");
 	}
 
-	void Window::set_size(glm::uvec2 p_new_size)
+	void Window::on_size_callback(const glm::uvec2& p_new_size)
 	{
 		if (p_new_size.x == 0 || p_new_size.y == 0) // When the window is minimised the size can be 0. Ignore and keep original size data.
 			return;
 
 		ImGuiIO& io = ImGui::GetIO();
-		io.FontGlobalScale = std::round(ImGui::GetMainViewport()->DpiScale);
 
 		if (m_fullscreen)
 		{
@@ -106,19 +121,27 @@ namespace Platform
 			io.DisplaySize  = ImVec2(static_cast<float>(m_size_windowed.x), static_cast<float>(m_size_windowed.y));
 		}
 
-		//mWindowResizeEvent.dispatch(new_size.x, new_size.y);
-
 		LOG("[WINDOW] Resized to {}x{} aspect: {}", size().x, size().y, aspect_ratio());
 	}
-	void Window::set_position(glm::uvec2 p_new_position)
+	void Window::set_size(const glm::uvec2& p_new_size)
+	{
+		glfwSetWindowSize(m_handle, p_new_size.x, p_new_size.y);
+		on_size_callback(p_new_size);
+	}
+	void Window::on_position_callback(const glm::uvec2& new_position)
 	{
 		if (m_fullscreen)
-			m_position_fullscreen = p_new_position;
+			m_position_fullscreen = new_position;
 		else
-			m_position_windowed = p_new_position;
+			m_position_windowed = new_position;
 
 		LOG("[WINDOW] Moved to {}, {}", position().x, position().y, aspect_ratio());
 	}
+	void Window::set_position(const glm::uvec2& p_new_position)
+	{
+		glfwSetWindowPos(m_handle, p_new_position.x, p_new_position.y);
+		on_position_callback(p_new_position);
+	}
 
 	void Window::request_close()
 	{
@@ -142,8 +165,8 @@ namespace Platform
 		{
 			const auto max_res = get_max_resolution();
 			glfwSetWindowMonitor(m_handle, glfwGetPrimaryMonitor(), 0, 0, max_res.x, max_res.y, GLFW_DONT_CARE);
-			set_position({0, 0});
-			set_size(max_res);
+			on_position_callback({0, 0});
+			on_size_callback(max_res);
 			LOG("[WINDOW] Set to fullscreen. Position: {},{} Resolution: {}x{} Aspect ratio: {}", 0, 0, m_size_fullscreen.x, m_size_fullscreen.y, m_aspect_ratio);
 		}
 		else // Windowed mode. Reuse the old size and position
@@ -217,6 +240,18 @@ namespace Platform
 		ImGui_ImplOpenGL3_RenderDrawData(ImGui::GetDrawData());
 	}
 
+	void Window::on_content_scale_callback(float new_scale)
+	{
+		ImGuiIO& io        = ImGui::GetIO();
+		io.FontGlobalScale = new_scale;
+	}
+	float Window::get_content_scale() const
+	{
+		float xscale, yscale;
+		glfwGetWindowContentScale(m_handle, &xscale, &yscale);
+		return (xscale + yscale) * 0.5f;
+	}
+
 	int Window::get_window_title_bar_height()
 	{
 #ifdef _WIN32

source/Platform/Window.hpp

@@ -27,17 +27,19 @@ namespace Platform
 		// Creates a OS window of p_width and p_height.
 		// Takes an Input and sets its GLFW callback functions. Input depends on a Window.
 		// Window construction requires GLFW and ImGui to be initialised before.
-		Window(const int& p_width, const int& p_height, Input& p_input_state) noexcept;
+		Window(const glm::vec2& p_screen_factor, Input& p_input_state) noexcept;
 		~Window() noexcept;
 
 		void set_VSync(bool p_enabled);
 		bool get_VSync() const { return m_VSync; };
 
 		glm::uvec2 size() const { return m_fullscreen ? m_size_fullscreen : m_size_windowed; };
-		void set_size(glm::uvec2 p_new_size);
+		void on_size_callback(const glm::uvec2& p_new_size);
+		void set_size(const glm::uvec2& p_new_size);
 
 		glm::uvec2 position() const { return m_fullscreen ? m_position_fullscreen : m_position_windowed; };
-		void set_position(glm::uvec2 p_new_position);
+		void on_position_callback(const glm::uvec2& p_new_position);
+		void set_position(const glm::uvec2& p_new_position);
 
 		void toggle_fullscreen();
 		void swap_buffers();
@@ -47,6 +49,9 @@ namespace Platform
 		bool close_requested() const { return m_close_requested; };
 		float aspect_ratio()   const { return m_aspect_ratio; };
 
+		void on_content_scale_callback(float new_scale);
+		float get_content_scale() const;
+
 		// Returns the hight of the window title bar in pixels.
 		static int get_window_title_bar_height();
 		// Get the max resolution of the primary monitor.