mirror of
https://github.com/open-goal/jak-project.git
synced 2024-10-20 11:26:18 -04:00
d819d6da05
Some checks failed
Lint / 📝 Optional Checks (push) Has been cancelled
Build / 🖥️ Windows (push) Has been cancelled
Build / 🐧 Linux (push) Has been cancelled
Build / 🍎 MacOS (push) Has been cancelled
Inform Pages Repo / Generate Documentation (push) Has been cancelled
Lint / 📝 Formatting (push) Has been cancelled
Lint / 📝 Required Checks (push) Has been cancelled
Fixes https://github.com/open-goal/jak-project/issues/3563 These users have the following spamming in logs: > OpenGL error 0x502 S8246 T824C: GL_INVALID_OPERATION error generated. Source and destination dimensions must be identical with the current filtering modes. And the solution is to correctly set their game-size. The way this change accomplishes that is by confirming whether or not the set `game-size` is a valid resolution informed by SDL, if not, it defaults to the monitor's currently set display mode's resolution. This also moves the selected display id, and the display mode into the C++ settings -- closer to where it's actually managed and used. I'm tempted to do this eventually for the resolutions as well but that stuff is much more burdensome. This hopefully simplifies debugging, reduces startup flickering, and removes back-and-forth complexity. Hopefully this makes debugging display related problems easier. It also adds a bunch more logging to the related code.
395 lines
15 KiB
C++
395 lines
15 KiB
C++
#include "display_manager.h"
|
|
|
|
#include "sdl_util.h"
|
|
|
|
#include "common/global_profiler/GlobalProfiler.h"
|
|
|
|
#include "fmt/core.h"
|
|
#include "fmt/format.h"
|
|
|
|
DisplayManager::DisplayManager(SDL_Window* window) : m_window(window) {
|
|
prof().instant_event("ROOT");
|
|
{
|
|
auto p = scoped_prof("display_manager::init");
|
|
// initialize settings
|
|
m_display_settings = game_settings::DisplaySettings();
|
|
#ifdef _WIN32
|
|
// Windows hint to disable OS level forced scaling and allow native resolution at non 100%
|
|
// scales
|
|
SetProcessDPIAware();
|
|
#endif
|
|
update_curr_display_info();
|
|
update_video_modes();
|
|
// Load from file now (after initializing current window settings)
|
|
m_display_settings.load_settings();
|
|
// Adjust window / monitor position
|
|
initialize_window_position_from_settings();
|
|
set_display_mode(m_display_settings.display_mode);
|
|
}
|
|
}
|
|
|
|
DisplayManager::~DisplayManager() {
|
|
prof().instant_event("ROOT");
|
|
{
|
|
auto p = scoped_prof("display_manager::destroy");
|
|
if (m_display_settings.display_mode == game_settings::DisplaySettings::DisplayMode::Windowed) {
|
|
m_display_settings.window_xpos = m_window_xpos;
|
|
m_display_settings.window_ypos = m_window_ypos;
|
|
}
|
|
m_display_settings.save_settings();
|
|
}
|
|
}
|
|
|
|
void DisplayManager::initialize_window_position_from_settings() {
|
|
// Check that the display id is still valid
|
|
if (m_current_display_modes.find(m_display_settings.display_id) ==
|
|
m_current_display_modes.end()) {
|
|
lg::warn("[DISPLAY] Saved display ID is no longer valid, resetting to display 0");
|
|
m_display_settings.display_id = 0;
|
|
m_display_settings.window_xpos = 50;
|
|
m_display_settings.window_ypos = 50;
|
|
m_display_settings.save_settings();
|
|
}
|
|
|
|
SDL_Rect rect;
|
|
const auto ok = SDL_GetDisplayBounds(m_display_settings.display_id, &rect);
|
|
if (ok < 0) {
|
|
sdl_util::log_error(fmt::format("unable to get display bounds for display id {}",
|
|
m_display_settings.display_id));
|
|
} else {
|
|
// Adjust the settings if they are out of bounds
|
|
if (m_display_settings.window_xpos <= rect.x ||
|
|
m_display_settings.window_xpos + 50 >= rect.x + rect.w) {
|
|
lg::warn("[DISPLAY] Saved xpos is out of bounds, resetting");
|
|
m_display_settings.window_xpos = rect.x + 50;
|
|
m_display_settings.save_settings();
|
|
}
|
|
if (m_display_settings.window_ypos <= rect.y ||
|
|
m_display_settings.window_ypos + 50 > rect.y + rect.h) {
|
|
lg::warn("[DISPLAY] Saved ypos is out of bounds, resetting");
|
|
m_display_settings.window_ypos = rect.y + 50;
|
|
m_display_settings.save_settings();
|
|
}
|
|
}
|
|
|
|
SDL_SetWindowPosition(m_window, m_display_settings.window_xpos, m_display_settings.window_ypos);
|
|
}
|
|
|
|
void DisplayManager::process_sdl_event(const SDL_Event& event) {
|
|
const auto event_type = event.type;
|
|
if (event_type == SDL_WINDOWEVENT) {
|
|
// https://wiki.libsdl.org/SDL2/SDL_WindowEvent
|
|
// https://wiki.libsdl.org/SDL2/SDL_WindowEventID
|
|
switch (event.window.event) {
|
|
case SDL_WINDOWEVENT_MINIMIZED:
|
|
m_window_state = WindowState::Minimized;
|
|
break;
|
|
case SDL_WINDOWEVENT_MAXIMIZED:
|
|
m_window_state = WindowState::Maximized;
|
|
break;
|
|
case SDL_WINDOWEVENT_RESTORED:
|
|
m_window_state = WindowState::Restored;
|
|
break;
|
|
case SDL_WINDOWEVENT_MOVED:
|
|
m_window_xpos = event.window.data1;
|
|
m_window_ypos = event.window.data2;
|
|
break;
|
|
case SDL_WINDOWEVENT_RESIZED:
|
|
case SDL_WINDOWEVENT_SIZE_CHANGED:
|
|
m_window_width = event.window.data1;
|
|
m_window_height = event.window.data2;
|
|
break;
|
|
case SDL_WINDOWEVENT_DISPLAY_CHANGED:
|
|
// NOTE - if the user changes the window to a display that doesn't support the same
|
|
// framerate we don't handle that
|
|
update_curr_display_info();
|
|
break;
|
|
case SDL_WINDOWEVENT_ENTER:
|
|
if (m_input_manager && m_input_manager.value()->auto_hiding_cursor()) {
|
|
m_input_manager.value()->hide_cursor(true);
|
|
}
|
|
break;
|
|
case SDL_WINDOWEVENT_LEAVE:
|
|
m_input_manager.value()->hide_cursor(false);
|
|
break;
|
|
}
|
|
} else if (event_type == SDL_DISPLAYEVENT) {
|
|
// https://wiki.libsdl.org/SDL2/SDL_DisplayEventID
|
|
switch (event.display.event) {
|
|
case SDL_DISPLAYEVENT_CONNECTED:
|
|
case SDL_DISPLAYEVENT_DISCONNECTED:
|
|
update_curr_display_info();
|
|
update_video_modes();
|
|
break;
|
|
case SDL_DISPLAYEVENT_ORIENTATION:
|
|
update_video_modes();
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
void DisplayManager::process_ee_events() {
|
|
const std::lock_guard<std::mutex> lock(event_queue_mtx);
|
|
// Fully process any events from the EE
|
|
while (!ee_event_queue.empty()) {
|
|
const auto& evt = ee_event_queue.front();
|
|
switch (evt.type) {
|
|
case EEDisplayEventType::SET_WINDOW_SIZE:
|
|
set_window_size(std::get<int>(evt.param1), std::get<int>(evt.param2));
|
|
break;
|
|
case EEDisplayEventType::SET_DISPLAY_MODE:
|
|
set_display_mode(std::get<game_settings::DisplaySettings::DisplayMode>(evt.param1));
|
|
break;
|
|
case EEDisplayEventType::SET_DISPLAY_ID:
|
|
set_display_id(std::get<int>(evt.param1));
|
|
break;
|
|
}
|
|
ee_event_queue.pop();
|
|
}
|
|
}
|
|
|
|
std::string DisplayManager::get_connected_display_name(int id) {
|
|
if (m_current_display_modes.find(id) != m_current_display_modes.end()) {
|
|
return m_current_display_modes.at(id).display_name;
|
|
}
|
|
return "";
|
|
}
|
|
|
|
int DisplayManager::get_active_display_refresh_rate() {
|
|
if (get_active_display_id() >= 0 &&
|
|
m_current_display_modes.find(get_active_display_id()) != m_current_display_modes.end()) {
|
|
return m_current_display_modes.at(get_active_display_id()).refresh_rate;
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
int DisplayManager::get_screen_width() {
|
|
if (get_active_display_id() >= 0 &&
|
|
m_current_display_modes.find(get_active_display_id()) != m_current_display_modes.end()) {
|
|
return m_current_display_modes.at(get_active_display_id()).screen_width;
|
|
}
|
|
return 640;
|
|
}
|
|
|
|
int DisplayManager::get_screen_height() {
|
|
if (get_active_display_id() >= 0 &&
|
|
m_current_display_modes.find(get_active_display_id()) != m_current_display_modes.end()) {
|
|
return m_current_display_modes.at(get_active_display_id()).screen_height;
|
|
}
|
|
return 480;
|
|
}
|
|
|
|
Resolution DisplayManager::get_resolution(int id) {
|
|
if (id < (int)m_available_resolutions.size()) {
|
|
return m_available_resolutions.at(id);
|
|
}
|
|
return {0, 0, 0.0};
|
|
}
|
|
|
|
bool DisplayManager::is_supported_resolution(int width, int height) {
|
|
for (const auto resolution : m_available_resolutions) {
|
|
if (resolution.width == width && resolution.height == height) {
|
|
return true;
|
|
}
|
|
}
|
|
lg::warn("[DISPLAY] {}x{} is not a supported resolution", width, height);
|
|
return false;
|
|
}
|
|
|
|
void DisplayManager::enqueue_set_window_size(int width, int height) {
|
|
const std::lock_guard<std::mutex> lock(event_queue_mtx);
|
|
ee_event_queue.push({EEDisplayEventType::SET_WINDOW_SIZE, width, height});
|
|
}
|
|
|
|
void DisplayManager::set_window_size(int width, int height) {
|
|
SDL_SetWindowSize(m_window, width, height);
|
|
}
|
|
|
|
void DisplayManager::enqueue_set_window_display_mode(
|
|
game_settings::DisplaySettings::DisplayMode mode) {
|
|
const std::lock_guard<std::mutex> lock(event_queue_mtx);
|
|
ee_event_queue.push({EEDisplayEventType::SET_DISPLAY_MODE, mode, {}});
|
|
}
|
|
|
|
void DisplayManager::set_display_mode(game_settings::DisplaySettings::DisplayMode mode) {
|
|
lg::info("[DISPLAY] Setting to display mode: {}", static_cast<int>(mode));
|
|
// https://wiki.libsdl.org/SDL2/SDL_SetWindowFullscreen
|
|
int result = 0;
|
|
switch (mode) {
|
|
case game_settings::DisplaySettings::DisplayMode::Windowed:
|
|
result = SDL_SetWindowFullscreen(m_window, 0);
|
|
if (result == 0) {
|
|
lg::info("[DISPLAY] windowed mode - resizing window to {}x{}", m_window_width,
|
|
m_window_height);
|
|
SDL_SetWindowSize(m_window, m_window_width, m_window_height);
|
|
} else {
|
|
sdl_util::log_error("unable to change window to windowed mode");
|
|
}
|
|
break;
|
|
case game_settings::DisplaySettings::DisplayMode::Fullscreen:
|
|
case game_settings::DisplaySettings::DisplayMode::Borderless:
|
|
// 1. exit fullscreen
|
|
result = SDL_SetWindowFullscreen(m_window, 0);
|
|
if (result == 0) {
|
|
SDL_Rect display_bounds;
|
|
result = SDL_GetDisplayBounds(get_active_display_id(), &display_bounds);
|
|
if (result < 0) {
|
|
sdl_util::log_error(fmt::format("unable to get display bounds for display id {}",
|
|
get_active_display_id()));
|
|
} else {
|
|
// 2. move it to the right monitor
|
|
lg::info("[DISPLAY] preparing fullscreen - moving window to {},{} on display id {}",
|
|
display_bounds.x + 50, display_bounds.y + 50, get_active_display_id());
|
|
SDL_SetWindowPosition(m_window, display_bounds.x + 50, display_bounds.y + 50);
|
|
if (mode == game_settings::DisplaySettings::DisplayMode::Fullscreen) {
|
|
update_video_modes();
|
|
// If fullscreen, we have to resize the window to take up the full resolution
|
|
//
|
|
// Some people are weird and don't use the monitor's maximum supported resolution
|
|
// in which case, we use what the user actually has selected.
|
|
const auto& display_res = m_current_display_modes.at(get_active_display_id());
|
|
lg::info("[DISPLAY] preparing fullscreen - setting window resolution to {}x{}",
|
|
display_res.screen_width, display_res.screen_height);
|
|
set_window_size(display_res.screen_width, display_res.screen_height);
|
|
}
|
|
// 3. fullscreen it!
|
|
result = SDL_SetWindowFullscreen(
|
|
m_window, mode == game_settings::DisplaySettings::DisplayMode::Fullscreen
|
|
? SDL_WINDOW_FULLSCREEN
|
|
: SDL_WINDOW_FULLSCREEN_DESKTOP);
|
|
if (result < 0) {
|
|
sdl_util::log_error("unable to switch window fullscreen or borderless fullscreen");
|
|
}
|
|
}
|
|
} else {
|
|
sdl_util::log_error(
|
|
"unable to switch window to windowed mode in order to change fullscreen modes");
|
|
}
|
|
break;
|
|
}
|
|
if (result != 0) {
|
|
sdl_util::log_error(
|
|
fmt::format("unable to change window display mode to {}", fmt::underlying(mode)));
|
|
} else {
|
|
// Set the mode, now that we've been successful
|
|
m_display_settings.display_mode = mode;
|
|
m_display_settings.save_settings();
|
|
}
|
|
}
|
|
|
|
void DisplayManager::enqueue_set_display_id(int display_id) {
|
|
const std::lock_guard<std::mutex> lock(event_queue_mtx);
|
|
ee_event_queue.push({EEDisplayEventType::SET_DISPLAY_ID, display_id, {}});
|
|
}
|
|
|
|
void DisplayManager::set_display_id(int display_id) {
|
|
lg::info("[DISPLAY] Setting display id to: {}", display_id);
|
|
if (display_id >= (int)m_current_display_modes.size()) {
|
|
display_id = 0;
|
|
}
|
|
m_display_settings.display_id = display_id;
|
|
if (get_display_mode() != game_settings::DisplaySettings::DisplayMode::Windowed) {
|
|
set_display_mode((game_settings::DisplaySettings::DisplayMode)m_display_settings.display_mode);
|
|
}
|
|
m_display_settings.save_settings();
|
|
}
|
|
|
|
void DisplayManager::update_curr_display_info() {
|
|
lg::info("[DISPLAY] Updating current display info");
|
|
m_display_settings.display_id = SDL_GetWindowDisplayIndex(m_window);
|
|
if (get_active_display_id() < 0) {
|
|
sdl_util::log_error("could not retrieve current window's display index");
|
|
}
|
|
lg::info("[DISPLAY] current display id is {}", m_display_settings.display_id);
|
|
SDL_GL_GetDrawableSize(m_window, &m_window_width, &m_window_height);
|
|
SDL_GetWindowPosition(m_window, &m_window_xpos, &m_window_ypos);
|
|
// Update the scale of the display as well
|
|
// TODO - figure out how to do this on SDL
|
|
// https://github.com/libsdl-org/SDL/commit/ab81a559f43abc0858c96788f8e00bbb352287e8
|
|
m_window_scale_x = 1.0;
|
|
m_window_scale_y = 1.0;
|
|
}
|
|
|
|
void DisplayManager::update_video_modes() {
|
|
lg::info("[DISPLAY] Enumerating video modes");
|
|
const auto num_displays = SDL_GetNumVideoDisplays();
|
|
if (num_displays < 0) {
|
|
sdl_util::log_error("could not retrieve number of displays");
|
|
return;
|
|
}
|
|
|
|
m_current_display_modes.clear();
|
|
|
|
SDL_DisplayMode curr_mode;
|
|
for (int display_id = 0; display_id < num_displays; display_id++) {
|
|
const auto success = SDL_GetCurrentDisplayMode(display_id, &curr_mode);
|
|
if (success != 0) {
|
|
sdl_util::log_error(
|
|
fmt::format("couldn't retrieve current display mode for display id {}", display_id));
|
|
continue;
|
|
}
|
|
auto display_orient = SDL_GetDisplayOrientation(display_id);
|
|
Orientation orient = Orientation::Unknown;
|
|
switch (display_orient) {
|
|
case SDL_ORIENTATION_LANDSCAPE:
|
|
orient = Orientation::Landscape;
|
|
break;
|
|
case SDL_ORIENTATION_LANDSCAPE_FLIPPED:
|
|
orient = Orientation::LandscapeFlipped;
|
|
break;
|
|
case SDL_ORIENTATION_PORTRAIT:
|
|
orient = Orientation::Portrait;
|
|
break;
|
|
case SDL_ORIENTATION_PORTRAIT_FLIPPED:
|
|
orient = Orientation::PortraitFlipped;
|
|
break;
|
|
default:
|
|
orient = Orientation::Unknown;
|
|
}
|
|
|
|
std::string display_name_str = "";
|
|
const auto display_name = SDL_GetDisplayName(display_id);
|
|
if (display_name == NULL) {
|
|
sdl_util::log_error(fmt::format("couldn't retrieve display name with id {}", display_id));
|
|
} else {
|
|
display_name_str = display_name;
|
|
}
|
|
|
|
DisplayMode new_mode = {display_name_str, curr_mode.format, curr_mode.w,
|
|
curr_mode.h, curr_mode.refresh_rate, orient};
|
|
m_current_display_modes[display_id] = new_mode;
|
|
}
|
|
update_resolutions();
|
|
}
|
|
|
|
void DisplayManager::update_resolutions() {
|
|
lg::info("[DISPLAY] Enumerating resolutions");
|
|
// Enumerate display's display modes to get the resolutions
|
|
auto num_display_modes = SDL_GetNumDisplayModes(get_active_display_id());
|
|
SDL_DisplayMode curr_mode;
|
|
for (int i = 0; i < num_display_modes; i++) {
|
|
auto ok = SDL_GetDisplayMode(get_active_display_id(), i, &curr_mode);
|
|
if (ok != 0) {
|
|
sdl_util::log_error(fmt::format("unable to get display mode for display {}, index {}",
|
|
get_active_display_id(), i));
|
|
continue;
|
|
}
|
|
Resolution new_res = {curr_mode.w, curr_mode.h,
|
|
static_cast<float>(curr_mode.w) / static_cast<float>(curr_mode.h)};
|
|
m_available_resolutions.push_back(new_res);
|
|
}
|
|
|
|
// Sort by area
|
|
std::sort(m_available_resolutions.begin(), m_available_resolutions.end(),
|
|
[](const Resolution& a, const Resolution& b) -> bool {
|
|
return a.width * a.height > b.width * b.height;
|
|
});
|
|
|
|
// Remove duplicate resolutions
|
|
auto last = std::unique(m_available_resolutions.begin(), m_available_resolutions.end(),
|
|
[](const Resolution& a, const Resolution& b) -> bool {
|
|
return (a.width == b.width && a.height == b.height);
|
|
});
|
|
m_available_resolutions.erase(last, m_available_resolutions.end());
|
|
}
|