void log_out_driver_modes(const int color_depth)
{
IGfxModeList *modes = gfxDriver->GetSupportedModeList(color_depth);
if (!modes)
{
Out::FPrint("Couldn't get a list of supported resolutions for color depth = %d", color_depth);
return;
}
const int mode_count = modes->GetModeCount();
DisplayResolution mode;
String mode_str;
for (int i = 0, in_str = 0; i < mode_count; ++i)
{
if (!modes->GetMode(i, mode) || mode.ColorDepth != color_depth)
continue;
mode_str.Append(String::FromFormat("%dx%d;", mode.Width, mode.Height));
if (++in_str % 8 == 0)
mode_str.Append("\n\t");
}
delete modes;
String out_str = String::FromFormat("Supported gfx modes (%d-bit): ", color_depth);
if (!mode_str.IsEmpty())
{
out_str.Append("\n\t");
out_str.Append(mode_str);
}
else
out_str.Append("none");
Out::FPrint(out_str);
}
int find_max_supported_uniform_scaling(const Size &base_size, Size &found_size, const int color_depth,
const Size *ratio_reference = NULL, const bool keep_width = false, const bool keep_height = false)
{
IGfxModeList *modes = gfxDriver->GetSupportedModeList(color_depth);
if (!modes)
{
Out::FPrint("Couldn't get a list of supported resolutions");
return 0;
}
int wanted_ratio = 0;
if (ratio_reference)
{
wanted_ratio = (ratio_reference->Height << 10) / ratio_reference->Width;
}
int least_supported_scaling = 0;
int mode_count = modes->GetModeCount();
DisplayResolution mode;
for (int i = 0; i < mode_count; ++i)
{
if (!modes->GetMode(i, mode))
{
continue;
}
if (mode.ColorDepth != color_depth)
{
continue;
}
if (wanted_ratio > 0)
{
int mode_ratio = (mode.Height << 10) / mode.Width;
if (mode_ratio != wanted_ratio)
{
continue;
}
}
if (mode.Width >= base_size.Width &&
mode.Height >= base_size.Height)
{
int scaling_factor;
if (is_scaling_supported(base_size, mode, 0, scaling_factor) &&
(!keep_width || mode.Width / scaling_factor == base_size.Width) &&
(!keep_height || mode.Height / scaling_factor == base_size.Height) &&
scaling_factor > least_supported_scaling)
{
found_size = Size(mode.Width, mode.Height);
least_supported_scaling = scaling_factor;
}
}
}
delete modes;
return least_supported_scaling;
}
int find_max_supported_uniform_multiplier(const Size &base_size, const int color_depth, int width_range_allowed)
{
IGfxModeList *modes = gfxDriver->GetSupportedModeList(color_depth);
if (!modes)
{
Out::FPrint("Couldn't get a list of supported resolutions");
return 0;
}
int least_supported_multiplier = 0;
int mode_count = modes->GetModeCount();
DisplayResolution mode;
for (int i = 0; i < mode_count; ++i)
{
if (!modes->GetMode(i, mode))
{
continue;
}
if (mode.ColorDepth != color_depth)
{
continue;
}
if (mode.Width > base_size.Width &&
mode.Height > base_size.Height && mode.Height % base_size.Height == 0)
{
int multiplier_x = mode.Width / base_size.Width;
int remainder_x = mode.Width % base_size.Width;
int multiplier_y = mode.Height / base_size.Height;
if (multiplier_x == multiplier_y && (remainder_x / multiplier_x <= width_range_allowed) &&
multiplier_x > least_supported_multiplier)
{
least_supported_multiplier = multiplier_x;
}
}
}
delete modes;
if (least_supported_multiplier == 0)
{
Out::FPrint("Couldn't find acceptable supported resolution");
}
return least_supported_multiplier;
}
bool find_nearest_supported_mode(const Size &base_size, const int scaling_factor, Size &found_size, const int color_depth,
const Size *ratio_reference = NULL, const bool keep_width = false, const bool keep_height = false)
{
IGfxModeList *modes = gfxDriver->GetSupportedModeList(color_depth);
if (!modes)
{
Out::FPrint("Couldn't get a list of supported resolutions");
return false;
}
Size wanted_size = base_size * scaling_factor;
int wanted_ratio = 0;
if (ratio_reference)
{
wanted_ratio = (ratio_reference->Height << 10) / ratio_reference->Width;
}
int nearest_width = 0;
int nearest_height = 0;
int nearest_width_diff = 0;
int nearest_height_diff = 0;
int mode_count = modes->GetModeCount();
DisplayResolution mode;
for (int i = 0; i < mode_count; ++i)
{
if (!modes->GetMode(i, mode))
{
continue;
}
if (mode.ColorDepth != color_depth)
{
continue;
}
if (wanted_ratio > 0)
{
int mode_ratio = (mode.Height << 10) / mode.Width;
if (mode_ratio != wanted_ratio)
{
continue;
}
}
if (mode.Width == wanted_size.Width && mode.Height == wanted_size.Height)
{
nearest_width = mode.Width;
nearest_height = mode.Height;
break;
}
if (keep_width && mode.Width != wanted_size.Width ||
keep_height && mode.Height != wanted_size.Height ||
// current implementation does not allow downscaling
mode.Width < wanted_size.Width ||
mode.Height < wanted_size.Height)
{
continue;
}
int diff_w = abs(wanted_size.Width - mode.Width);
int diff_h = abs(wanted_size.Height - mode.Height);
bool same_diff_w_higher = (diff_w == nearest_width_diff && nearest_width < mode.Width);
bool same_diff_h_higher = (diff_h == nearest_height_diff && nearest_height < mode.Height);
int multiplier;
if (is_scaling_supported(base_size, mode, scaling_factor, multiplier) &&
nearest_width == 0 ||
(diff_w < nearest_width_diff || same_diff_w_higher) && diff_h <= nearest_height_diff ||
(diff_h < nearest_height_diff || same_diff_h_higher) && diff_w <= nearest_width_diff)
{
nearest_width = mode.Width;
nearest_width_diff = diff_w;
nearest_height = mode.Height;
nearest_height_diff = diff_h;
}
}
delete modes;
if (nearest_width > 0 && nearest_height > 0)
{
found_size.Width = nearest_width;
found_size.Height = nearest_height;
return true;
}
return false;
}
bool find_nearest_supported_mode(const IGfxModeList &modes, Size &wanted_size, int *mode_index, const int color_depth,
const Size *ratio_reference, const Size *upper_bound)
{
uint32_t wanted_ratio = 0;
if (ratio_reference && !ratio_reference->IsNull())
{
wanted_ratio = (ratio_reference->Height << kShift) / ratio_reference->Width;
}
int nearest_width = 0;
int nearest_height = 0;
int nearest_width_diff = 0;
int nearest_height_diff = 0;
int nearest_mode_index = -1;
int mode_count = modes.GetModeCount();
DisplayMode mode;
for (int i = 0; i < mode_count; ++i)
{
if (!modes.GetMode(i, mode))
{
continue;
}
if (mode.ColorDepth != color_depth)
{
continue;
}
if (wanted_ratio > 0)
{
uint32_t mode_ratio = (mode.Height << kShift) / mode.Width;
if (mode_ratio != wanted_ratio)
{
continue;
}
}
if (upper_bound && (mode.Width > upper_bound->Width || mode.Height > upper_bound->Height))
continue;
if (mode.Width == wanted_size.Width && mode.Height == wanted_size.Height)
{
nearest_width = mode.Width;
nearest_height = mode.Height;
nearest_mode_index = i;
break;
}
int diff_w = abs(wanted_size.Width - mode.Width);
int diff_h = abs(wanted_size.Height - mode.Height);
bool same_diff_w_higher = (diff_w == nearest_width_diff && nearest_width < wanted_size.Width);
bool same_diff_h_higher = (diff_h == nearest_height_diff && nearest_height < wanted_size.Height);
if (nearest_width == 0 ||
(diff_w < nearest_width_diff || same_diff_w_higher) && diff_h <= nearest_height_diff ||
(diff_h < nearest_height_diff || same_diff_h_higher) && diff_w <= nearest_width_diff)
{
nearest_width = mode.Width;
nearest_width_diff = diff_w;
nearest_height = mode.Height;
nearest_height_diff = diff_h;
nearest_mode_index = i;
}
}
if (nearest_width > 0 && nearest_height > 0)
{
wanted_size.Width = nearest_width;
wanted_size.Height = nearest_height;
if (mode_index)
*mode_index = nearest_mode_index;
return true;
}
return false;
}
int find_supported_resolution_width(const Size &ideal_size, int color_depth, int width_range_allowed)
{
// Temporary hack for incomplete OpenGL driver (always returns ideal width)
if (strcmp(gfxDriver->GetDriverID(), "OGL") == 0)
{
return ideal_size.Width;
}
IGfxModeList *modes = gfxDriver->GetSupportedModeList(color_depth);
if (!modes)
{
Out::FPrint("Couldn't get a list of supported resolutions");
return 0;
}
int ideal_width_scaled = ideal_size.Width;
int ideal_height_scaled = ideal_size.Height;
filter->GetRealResolution(&ideal_width_scaled, &ideal_height_scaled);
const int filter_factor = ideal_width_scaled / ideal_size.Width;
const int max_width_diff = width_range_allowed * filter_factor;
int nearest_width = 0;
int mode_count = modes->GetModeCount();
DisplayResolution mode;
for (int i = 0; i < mode_count; ++i)
{
if (!modes->GetMode(i, mode))
{
continue;
}
if (mode.ColorDepth != color_depth)
{
continue;
}
if (mode.Height == ideal_height_scaled)
{
if (mode.Width == ideal_width_scaled)
{
nearest_width = mode.Width;
break;
}
const int mode_diff = abs(mode.Width - ideal_width_scaled);
const int nearest_diff = abs(nearest_width - ideal_width_scaled);
if (mode_diff <= max_width_diff &&
(mode_diff < nearest_diff ||
mode_diff == nearest_diff && mode.Width > nearest_diff))
{
nearest_width = mode.Width;
}
}
}
delete modes;
if (nearest_width == 0)
{
Out::FPrint("Couldn't find acceptable supported resolution");
}
return nearest_width / filter_factor;
}
