mirror/RetroArch
1
0
Fork 0
mirror of https://github.com/libretro/RetroArch synced 2025-03-02 19:13:34 +00:00
Code Issues Packages Projects Releases Wiki Activity

refactor some video_shader_parse functions

Browse Source 
- video_shader_parse_type()'s fallback only worked for NULL paths and was wrongly used, now returns RARCH_SHADER_NONE like video_shader_get_type_from_ext().
 - video_shader_get_type_from_ext() should not be checking video driver flags, this is instead done by video_shader_is_supported()
 - video_driver_get_all_flags() did not actually 'get' flags, changed to video_driver_test_all_flags()

workaround for crash due to glcore not always using at least OpenGL 3.2
This commit is contained in:
LazyBumHorse 2019-06-17 18:26:41 +02:00
parent da1d03bcb0
commit 42e35c825f
17 changed files with 177 additions and 265 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
command.c
View File

@ -254,7 +254,7 @@ bool command_set_shader(const char *arg)
enum rarch_shader_type type = video_shader_get_type_from_ext(
path_get_extension(arg), &is_preset);
if (type == RARCH_SHADER_NONE)
if (type == RARCH_SHADER_NONE || !video_shader_is_supported(type))
return false;
snprintf(msg, sizeof(msg),

3
gfx/drivers/d3d9.c
View File

@ -1274,8 +1274,7 @@ static bool d3d9_init_internal(d3d9_video_t *d3d,
if (settings->bools.video_shader_enable)
{
enum rarch_shader_type type =
video_shader_parse_type(retroarch_get_shader_preset(),
RARCH_SHADER_NONE);
video_shader_parse_type(retroarch_get_shader_preset());
switch (type)
{

10
gfx/drivers/gl.c
View File

@ -2075,15 +2075,11 @@ static bool gl2_shader_init(gl_t *gl, const gfx_ctx_driver_t *ctx_driver,
{
video_shader_ctx_init_t init_data;
bool ret = false;
enum rarch_shader_type type = DEFAULT_SHADER_TYPE;
const char *shader_path = retroarch_get_shader_preset();
enum rarch_shader_type type = video_shader_parse_type(shader_path);
if (shader_path)
{
type = video_shader_parse_type(shader_path,
gl->core_context_in_use
? RARCH_SHADER_GLSL : DEFAULT_SHADER_TYPE);
}
if (type == RARCH_SHADER_NONE)
type = gl->core_context_in_use ? RARCH_SHADER_GLSL : DEFAULT_SHADER_TYPE;
switch (type)
{

4
gfx/drivers/gl_core.c
View File

@ -779,9 +779,9 @@ static bool gl_core_init_filter_chain_preset(gl_core_t *gl, const char *shader_p
static bool gl_core_init_filter_chain(gl_core_t *gl)
{
const char *shader_path = retroarch_get_shader_preset();
const char *shader_path = retroarch_get_shader_preset();
enum rarch_shader_type type = video_shader_parse_type(shader_path, RARCH_SHADER_NONE);
enum rarch_shader_type type = video_shader_parse_type(shader_path);
if (type == RARCH_SHADER_NONE)
{

2
gfx/drivers/metal.m
View File

@ -73,7 +73,7 @@ static void *metal_init(const video_info_t *video,
if (shader_path)
{
enum rarch_shader_type type = video_shader_parse_type(shader_path, RARCH_SHADER_SLANG);
enum rarch_shader_type type = video_shader_parse_type(shader_path);
metal_set_shader(((__bridge void *)md), type, shader_path);
}

2
gfx/drivers/vulkan.c
View File

@ -830,7 +830,7 @@ static bool vulkan_init_filter_chain(vk_t *vk)
{
const char *shader_path = retroarch_get_shader_preset();
enum rarch_shader_type type = video_shader_parse_type(shader_path, RARCH_SHADER_NONE);
enum rarch_shader_type type = video_shader_parse_type(shader_path);
if (type == RARCH_SHADER_NONE)
{

2
gfx/drivers_shader/shader_gl_core.cpp
View File

@ -719,7 +719,7 @@ void Framebuffer::init()
levels = num_miplevels(size.width, size.height);
if (max_levels < levels)
levels = max_levels;
levels = max_levels;
if (levels == 0)
levels = 1;

35
gfx/video_shader_parse.c
View File

@ -1130,7 +1130,6 @@ void video_shader_write_conf_preset(config_file_t *conf,
bool video_shader_is_supported(enum rarch_shader_type type)
{
gfx_ctx_flags_t flags;
enum display_flags flag = GFX_CTX_FLAGS_NONE;
switch (type)
@ -1152,10 +1151,7 @@ bool video_shader_is_supported(enum rarch_shader_type type)
return false;
}
if (video_driver_get_all_flags(&flags, flag))
return true;
return false;
return video_driver_test_all_flags(flag);
}
bool video_shader_any_supported(void)
@ -1193,10 +1189,7 @@ enum rarch_shader_type video_shader_get_type_from_ext(const char *ext,
if (string_is_equal_case_insensitive(ext, "cgp") ||
string_is_equal_case_insensitive(ext, "cg")
)
{
if (video_driver_get_all_flags(&flags, GFX_CTX_FLAGS_SHADERS_CG))
return RARCH_SHADER_CG;
}
return RARCH_SHADER_CG;
}
{
@ -1204,10 +1197,7 @@ enum rarch_shader_type video_shader_get_type_from_ext(const char *ext,
if (string_is_equal_case_insensitive(ext, "glslp") ||
string_is_equal_case_insensitive(ext, "glsl")
)
{
if (video_driver_get_all_flags(&flags, GFX_CTX_FLAGS_SHADERS_GLSL))
return RARCH_SHADER_GLSL;
}
return RARCH_SHADER_GLSL;
}
{
@ -1215,10 +1205,7 @@ enum rarch_shader_type video_shader_get_type_from_ext(const char *ext,
if (string_is_equal_case_insensitive(ext, "slangp") ||
string_is_equal_case_insensitive(ext, "slang")
)
{
if (video_driver_get_all_flags(&flags, GFX_CTX_FLAGS_SHADERS_SLANG))
return RARCH_SHADER_SLANG;
}
return RARCH_SHADER_SLANG;
}
return RARCH_SHADER_NONE;
@ -1227,22 +1214,18 @@ enum rarch_shader_type video_shader_get_type_from_ext(const char *ext,
/**
* video_shader_parse_type:
* @path : Shader path.
* @fallback : Fallback shader type in case no
* type could be found.
*
* Parses type of shader.
*
* Returns: value of shader type on success, otherwise will return
* user-supplied @fallback value.
* Returns: value of shader type if it could be determined,
* otherwise RARCH_SHADER_NONE.
**/
enum rarch_shader_type video_shader_parse_type(const char *path,
enum rarch_shader_type fallback)
enum rarch_shader_type video_shader_parse_type(const char *path)
{
bool is_preset = false;
if (!path)
return fallback;
return video_shader_get_type_from_ext(path_get_extension(path),
&is_preset);
return RARCH_SHADER_NONE;
return video_shader_get_type_from_ext(path_get_extension(path), &is_preset);
}
/**

9
gfx/video_shader_parse.h
View File

@ -233,16 +233,13 @@ bool video_shader_resolve_parameters(config_file_t *conf,
/**
* video_shader_parse_type:
* @path : Shader path.
* @fallback : Fallback shader type in case no
* type could be found.
*
* Parses type of shader.
*
* Returns: value of shader type on success, otherwise will return
* user-supplied @fallback value.
* Returns: value of shader type if it could be determined,
* otherwise RARCH_SHADER_NONE.
**/
enum rarch_shader_type video_shader_parse_type(const char *path,
enum rarch_shader_type fallback);
enum rarch_shader_type video_shader_parse_type(const char *path);
enum rarch_shader_type video_shader_get_type_from_ext(const char *ext,
bool *is_preset);

27
list_special.c
View File

@ -98,31 +98,22 @@ struct string_list *dir_list_new_special(const char *input_dir,
attr.i = 0;
if (video_driver_test_all_flags(GFX_CTX_FLAGS_SHADERS_CG))
{
gfx_ctx_flags_t flags;
if (video_driver_get_all_flags(&flags, GFX_CTX_FLAGS_SHADERS_CG))
{
string_list_append(str_list, "cgp", attr);
string_list_append(str_list, "cg", attr);
}
string_list_append(str_list, "cgp", attr);
string_list_append(str_list, "cg", attr);
}
if (video_driver_test_all_flags(GFX_CTX_FLAGS_SHADERS_GLSL))
{
gfx_ctx_flags_t flags;
if (video_driver_get_all_flags(&flags, GFX_CTX_FLAGS_SHADERS_GLSL))
{
string_list_append(str_list, "glslp", attr);
string_list_append(str_list, "glsl", attr);
}
string_list_append(str_list, "glslp", attr);
string_list_append(str_list, "glsl", attr);
}
if (video_driver_test_all_flags(GFX_CTX_FLAGS_SHADERS_SLANG))
{
gfx_ctx_flags_t flags;
if (video_driver_get_all_flags(&flags, GFX_CTX_FLAGS_SHADERS_SLANG))
{
string_list_append(str_list, "slangp", attr);
string_list_append(str_list, "slang", attr);
}
string_list_append(str_list, "slangp", attr);
string_list_append(str_list, "slang", attr);
}
string_list_join_concat(ext_shaders, sizeof(ext_shaders), str_list, "|");

2
menu/cbs/menu_cbs_ok.c
View File

@ -1457,7 +1457,7 @@ static int generic_action_ok(const char *path,
struct video_shader *shader = menu_shader_get();
flush_char = msg_hash_to_str(flush_id);
menu_shader_manager_set_preset(shader,
video_shader_parse_type(action_path, RARCH_SHADER_NONE),
video_shader_parse_type(action_path),
action_path);
}
break;

95
menu/menu_displaylist.c
View File

@ -6804,44 +6804,34 @@ bool menu_displaylist_ctl(enum menu_displaylist_ctl_state type,
MENU_SETTING_ACTION, 0, 0))
count++;
if (video_driver_test_all_flags(GFX_CTX_FLAGS_SHADERS_CG))
{
gfx_ctx_flags_t flags;
if (video_driver_get_all_flags(&flags, GFX_CTX_FLAGS_SHADERS_CG))
{
if (menu_entries_append_enum(info->list,
msg_hash_to_str(MENU_ENUM_LABEL_VALUE_UPDATE_CG_SHADERS),
msg_hash_to_str(MENU_ENUM_LABEL_UPDATE_CG_SHADERS),
MENU_ENUM_LABEL_UPDATE_CG_SHADERS,
MENU_SETTING_ACTION, 0, 0))
count++;
}
if (menu_entries_append_enum(info->list,
msg_hash_to_str(MENU_ENUM_LABEL_VALUE_UPDATE_CG_SHADERS),
msg_hash_to_str(MENU_ENUM_LABEL_UPDATE_CG_SHADERS),
MENU_ENUM_LABEL_UPDATE_CG_SHADERS,
MENU_SETTING_ACTION, 0, 0))
count++;
}
if (video_driver_test_all_flags(GFX_CTX_FLAGS_SHADERS_GLSL))
{
gfx_ctx_flags_t flags;
if (video_driver_get_all_flags(&flags, GFX_CTX_FLAGS_SHADERS_GLSL))
{
if (menu_entries_append_enum(info->list,
msg_hash_to_str(MENU_ENUM_LABEL_VALUE_UPDATE_GLSL_SHADERS),
msg_hash_to_str(MENU_ENUM_LABEL_UPDATE_GLSL_SHADERS),
MENU_ENUM_LABEL_UPDATE_GLSL_SHADERS,
MENU_SETTING_ACTION, 0, 0))
count++;
}
if (menu_entries_append_enum(info->list,
msg_hash_to_str(MENU_ENUM_LABEL_VALUE_UPDATE_GLSL_SHADERS),
msg_hash_to_str(MENU_ENUM_LABEL_UPDATE_GLSL_SHADERS),
MENU_ENUM_LABEL_UPDATE_GLSL_SHADERS,
MENU_SETTING_ACTION, 0, 0))
count++;
}
if (video_driver_test_all_flags(GFX_CTX_FLAGS_SHADERS_SLANG))
{
gfx_ctx_flags_t flags;
if (video_driver_get_all_flags(&flags, GFX_CTX_FLAGS_SHADERS_SLANG))
{
if (menu_entries_append_enum(info->list,
msg_hash_to_str(MENU_ENUM_LABEL_VALUE_UPDATE_SLANG_SHADERS),
msg_hash_to_str(MENU_ENUM_LABEL_UPDATE_SLANG_SHADERS),
MENU_ENUM_LABEL_UPDATE_SLANG_SHADERS,
MENU_SETTING_ACTION, 0, 0))
count++;
}
if (menu_entries_append_enum(info->list,
msg_hash_to_str(MENU_ENUM_LABEL_VALUE_UPDATE_SLANG_SHADERS),
msg_hash_to_str(MENU_ENUM_LABEL_UPDATE_SLANG_SHADERS),
MENU_ENUM_LABEL_UPDATE_SLANG_SHADERS,
MENU_SETTING_ACTION, 0, 0))
count++;
}
#endif
}
@ -7474,37 +7464,28 @@ bool menu_displaylist_ctl(enum menu_displaylist_ctl_state type,
else if (type == DISPLAYLIST_SHADER_PASS)
info->type_default = FILE_TYPE_SHADER;
if (video_driver_test_all_flags(GFX_CTX_FLAGS_SHADERS_CG))
{
gfx_ctx_flags_t flags;
if (video_driver_get_all_flags(&flags, GFX_CTX_FLAGS_SHADERS_CG))
{
if (type == DISPLAYLIST_SHADER_PRESET)
string_list_append(str_list, "cgp", attr);
else if (type == DISPLAYLIST_SHADER_PASS)
string_list_append(str_list, "cg", attr);
}
if (type == DISPLAYLIST_SHADER_PRESET)
string_list_append(str_list, "cgp", attr);
else if (type == DISPLAYLIST_SHADER_PASS)
string_list_append(str_list, "cg", attr);
}
if (video_driver_test_all_flags(GFX_CTX_FLAGS_SHADERS_GLSL))
{
gfx_ctx_flags_t flags;
if (video_driver_get_all_flags(&flags, GFX_CTX_FLAGS_SHADERS_GLSL))
{
if (type == DISPLAYLIST_SHADER_PRESET)
string_list_append(str_list, "glslp", attr);
else if (type == DISPLAYLIST_SHADER_PASS)
string_list_append(str_list, "glsl", attr);
}
if (type == DISPLAYLIST_SHADER_PRESET)
string_list_append(str_list, "glslp", attr);
else if (type == DISPLAYLIST_SHADER_PASS)
string_list_append(str_list, "glsl", attr);
}
if (video_driver_test_all_flags(GFX_CTX_FLAGS_SHADERS_SLANG))
{
gfx_ctx_flags_t flags;
if (video_driver_get_all_flags(&flags, GFX_CTX_FLAGS_SHADERS_SLANG))
{
if (type == DISPLAYLIST_SHADER_PRESET)
string_list_append(str_list, "slangp", attr);
else if (type == DISPLAYLIST_SHADER_PASS)
string_list_append(str_list, "slang", attr);
}
if (type == DISPLAYLIST_SHADER_PRESET)
string_list_append(str_list, "slangp", attr);
else if (type == DISPLAYLIST_SHADER_PASS)
string_list_append(str_list, "slang", attr);
}
string_list_join_concat(new_exts, sizeof(new_exts), str_list, "|");

174
menu/menu_setting.c
View File

@ -8940,85 +8940,73 @@ static bool setting_append_list(
SETTINGS_DATA_LIST_CURRENT_ADD_FLAGS(list, list_info, SD_FLAG_CMD_APPLY_AUTO);
SETTINGS_DATA_LIST_CURRENT_ADD_FLAGS(list, list_info, SD_FLAG_LAKKA_ADVANCED);
if (video_driver_test_all_flags(GFX_CTX_FLAGS_CUSTOMIZABLE_SWAPCHAIN_IMAGES))
{
gfx_ctx_flags_t flags;
if (video_driver_get_all_flags(&flags, GFX_CTX_FLAGS_CUSTOMIZABLE_SWAPCHAIN_IMAGES))
{
CONFIG_UINT(
list, list_info,
&settings->uints.video_max_swapchain_images,
MENU_ENUM_LABEL_VIDEO_MAX_SWAPCHAIN_IMAGES,
MENU_ENUM_LABEL_VALUE_VIDEO_MAX_SWAPCHAIN_IMAGES,
DEFAULT_MAX_SWAPCHAIN_IMAGES,
&group_info,
&subgroup_info,
parent_group,
general_write_handler,
general_read_handler);
menu_settings_list_current_add_range(list, list_info, 1, 4, 1, true, true);
SETTINGS_DATA_LIST_CURRENT_ADD_FLAGS(list, list_info, SD_FLAG_CMD_APPLY_AUTO);
}
CONFIG_UINT(
list, list_info,
&settings->uints.video_max_swapchain_images,
MENU_ENUM_LABEL_VIDEO_MAX_SWAPCHAIN_IMAGES,
MENU_ENUM_LABEL_VALUE_VIDEO_MAX_SWAPCHAIN_IMAGES,
DEFAULT_MAX_SWAPCHAIN_IMAGES,
&group_info,
&subgroup_info,
parent_group,
general_write_handler,
general_read_handler);
menu_settings_list_current_add_range(list, list_info, 1, 4, 1, true, true);
SETTINGS_DATA_LIST_CURRENT_ADD_FLAGS(list, list_info, SD_FLAG_CMD_APPLY_AUTO);
}
if (video_driver_test_all_flags(GFX_CTX_FLAGS_HARD_SYNC))
{
gfx_ctx_flags_t flags;
if (video_driver_get_all_flags(&flags, GFX_CTX_FLAGS_HARD_SYNC))
{
CONFIG_BOOL(
list, list_info,
&settings->bools.video_hard_sync,
MENU_ENUM_LABEL_VIDEO_HARD_SYNC,
MENU_ENUM_LABEL_VALUE_VIDEO_HARD_SYNC,
DEFAULT_HARD_SYNC,
MENU_ENUM_LABEL_VALUE_OFF,
MENU_ENUM_LABEL_VALUE_ON,
&group_info,
&subgroup_info,
parent_group,
general_write_handler,
general_read_handler,
SD_FLAG_NONE
);
CONFIG_UINT(
list, list_info,
&settings->uints.video_hard_sync_frames,
MENU_ENUM_LABEL_VIDEO_HARD_SYNC_FRAMES,
MENU_ENUM_LABEL_VALUE_VIDEO_HARD_SYNC_FRAMES,
DEFAULT_HARD_SYNC_FRAMES,
&group_info,
&subgroup_info,
parent_group,
general_write_handler,
general_read_handler);
(*list)[list_info->index - 1].action_ok = &setting_action_ok_uint;
menu_settings_list_current_add_range(list, list_info, 0, 3, 1, true, true);
}
CONFIG_BOOL(
list, list_info,
&settings->bools.video_hard_sync,
MENU_ENUM_LABEL_VIDEO_HARD_SYNC,
MENU_ENUM_LABEL_VALUE_VIDEO_HARD_SYNC,
DEFAULT_HARD_SYNC,
MENU_ENUM_LABEL_VALUE_OFF,
MENU_ENUM_LABEL_VALUE_ON,
&group_info,
&subgroup_info,
parent_group,
general_write_handler,
general_read_handler,
SD_FLAG_NONE
);
CONFIG_UINT(
list, list_info,
&settings->uints.video_hard_sync_frames,
MENU_ENUM_LABEL_VIDEO_HARD_SYNC_FRAMES,
MENU_ENUM_LABEL_VALUE_VIDEO_HARD_SYNC_FRAMES,
DEFAULT_HARD_SYNC_FRAMES,
&group_info,
&subgroup_info,
parent_group,
general_write_handler,
general_read_handler);
(*list)[list_info->index - 1].action_ok = &setting_action_ok_uint;
menu_settings_list_current_add_range(list, list_info, 0, 3, 1, true, true);
}
if (video_driver_test_all_flags(GFX_CTX_FLAGS_ADAPTIVE_VSYNC))
{
gfx_ctx_flags_t flags;
if (video_driver_get_all_flags(&flags, GFX_CTX_FLAGS_ADAPTIVE_VSYNC))
{
CONFIG_BOOL(
list, list_info,
&settings->bools.video_adaptive_vsync,
MENU_ENUM_LABEL_VIDEO_ADAPTIVE_VSYNC,
MENU_ENUM_LABEL_VALUE_VIDEO_ADAPTIVE_VSYNC,
DEFAULT_ADAPTIVE_VSYNC,
MENU_ENUM_LABEL_VALUE_OFF,
MENU_ENUM_LABEL_VALUE_ON,
&group_info,
&subgroup_info,
parent_group,
general_write_handler,
general_read_handler,
SD_FLAG_NONE
);
}
CONFIG_BOOL(
list, list_info,
&settings->bools.video_adaptive_vsync,
MENU_ENUM_LABEL_VIDEO_ADAPTIVE_VSYNC,
MENU_ENUM_LABEL_VALUE_VIDEO_ADAPTIVE_VSYNC,
DEFAULT_ADAPTIVE_VSYNC,
MENU_ENUM_LABEL_VALUE_OFF,
MENU_ENUM_LABEL_VALUE_ON,
&group_info,
&subgroup_info,
parent_group,
general_write_handler,
general_read_handler,
SD_FLAG_NONE
);
}
CONFIG_UINT(
@ -9037,28 +9025,24 @@ static bool setting_append_list(
SETTINGS_DATA_LIST_CURRENT_ADD_FLAGS(list, list_info, SD_FLAG_LAKKA_ADVANCED);
#if !defined(RARCH_MOBILE)
if (video_driver_test_all_flags(GFX_CTX_FLAGS_BLACK_FRAME_INSERTION))
{
gfx_ctx_flags_t flags;
if (video_driver_get_all_flags(&flags, GFX_CTX_FLAGS_BLACK_FRAME_INSERTION))
{
CONFIG_BOOL(
list, list_info,
&settings->bools.video_black_frame_insertion,
MENU_ENUM_LABEL_VIDEO_BLACK_FRAME_INSERTION,
MENU_ENUM_LABEL_VALUE_VIDEO_BLACK_FRAME_INSERTION,
DEFAULT_BLACK_FRAME_INSERTION,
MENU_ENUM_LABEL_VALUE_OFF,
MENU_ENUM_LABEL_VALUE_ON,
&group_info,
&subgroup_info,
parent_group,
general_write_handler,
general_read_handler,
SD_FLAG_NONE
);
SETTINGS_DATA_LIST_CURRENT_ADD_FLAGS(list, list_info, SD_FLAG_LAKKA_ADVANCED);
}
CONFIG_BOOL(
list, list_info,
&settings->bools.video_black_frame_insertion,
MENU_ENUM_LABEL_VIDEO_BLACK_FRAME_INSERTION,
MENU_ENUM_LABEL_VALUE_VIDEO_BLACK_FRAME_INSERTION,
DEFAULT_BLACK_FRAME_INSERTION,
MENU_ENUM_LABEL_VALUE_OFF,
MENU_ENUM_LABEL_VALUE_ON,
&group_info,
&subgroup_info,
parent_group,
general_write_handler,
general_read_handler,
SD_FLAG_NONE
);
SETTINGS_DATA_LIST_CURRENT_ADD_FLAGS(list, list_info, SD_FLAG_LAKKA_ADVANCED);
}
#endif
END_SUB_GROUP(list, list_info, parent_group);
@ -11051,8 +11035,6 @@ static bool setting_append_list(
if (string_is_equal(settings->arrays.menu_driver, "rgui"))
{
gfx_ctx_flags_t flags;
CONFIG_BOOL(
list, list_info,
&settings->bools.menu_rgui_border_filler_enable,
@ -11116,7 +11098,7 @@ static bool setting_append_list(
general_read_handler,
SD_FLAG_NONE);
if (video_driver_get_all_flags(&flags, GFX_CTX_FLAGS_MENU_FRAME_FILTERING))
if (video_driver_test_all_flags(GFX_CTX_FLAGS_MENU_FRAME_FILTERING))
{
CONFIG_BOOL(
list, list_info,

3
menu/menu_shader.c
View File

@ -462,8 +462,7 @@ unsigned menu_shader_manager_get_type(const void *data)
for (i = 0; i < shader->passes; i++)
{
enum rarch_shader_type pass_type =
video_shader_parse_type(shader->pass[i].source.path,
RARCH_SHADER_NONE);
video_shader_parse_type(shader->pass[i].source.path);
switch (pass_type)
{

25
retroarch.c
View File

@ -10026,10 +10026,9 @@ bool video_context_driver_get_video_output_size(gfx_ctx_size_t *size_data)
bool video_context_driver_swap_interval(int *interval)
{
gfx_ctx_flags_t flags;
int current_interval = *interval;
settings_t *settings = configuration_settings;
bool adaptive_vsync_enabled = video_driver_get_all_flags(&flags, GFX_CTX_FLAGS_ADAPTIVE_VSYNC) && settings->bools.video_adaptive_vsync;
bool adaptive_vsync_enabled = video_driver_test_all_flags(GFX_CTX_FLAGS_ADAPTIVE_VSYNC) && settings->bools.video_adaptive_vsync;
if (!current_video_context.swap_interval)
return false;
@ -10172,19 +10171,23 @@ static bool video_driver_get_flags(gfx_ctx_flags_t *flags)
return true;
}
bool video_driver_get_all_flags(gfx_ctx_flags_t *flags, enum display_flags flag)
/**
* video_driver_test_all_flags:
* @testflag : flag to test
*
* Poll both the video and context driver's flags and test
* whether testflag is set or not.
**/
bool video_driver_test_all_flags(enum display_flags testflag)
{
if (!flags)
return false;
gfx_ctx_flags_t flags;
if (video_driver_get_flags(flags))
if (BIT32_GET(flags->flags, flag))
if (video_driver_get_flags(&flags))
if (BIT32_GET(flags.flags, testflag))
return true;
flags->flags = 0;
if (video_context_driver_get_flags(flags))
if (BIT32_GET(flags->flags, flag))
if (video_context_driver_get_flags(&flags))
if (BIT32_GET(flags.flags, testflag))
return true;
return false;

3
retroarch.h
View File

@ -2026,8 +2026,7 @@ bool video_driver_is_threaded(void);
bool video_context_driver_get_flags(gfx_ctx_flags_t *flags);
bool video_driver_get_all_flags(gfx_ctx_flags_t *flags,
enum display_flags flag);
bool video_driver_test_all_flags(enum display_flags testflag);
void video_driver_set_gpu_device_string(const char *str);

44
ui/drivers/qt/shaderparamsdialog.cpp
View File

@ -484,23 +484,14 @@ void ShaderParamsDialog::onShaderLoadPresetClicked()
filter = "Shader Preset (";
/* NOTE: Maybe we should have a way to get a list of all shader types instead of hard-coding this? */
{
gfx_ctx_flags_t flags;
if (video_driver_get_all_flags(&flags, GFX_CTX_FLAGS_SHADERS_CG))
filter += QLatin1Literal(" *") + file_path_str(FILE_PATH_CGP_EXTENSION);
}
if (video_driver_test_all_flags(GFX_CTX_FLAGS_SHADERS_CG))
filter += QLatin1Literal(" *") + file_path_str(FILE_PATH_CGP_EXTENSION);
{
gfx_ctx_flags_t flags;
if (video_driver_get_all_flags(&flags, GFX_CTX_FLAGS_SHADERS_GLSL))
filter += QLatin1Literal(" *") + file_path_str(FILE_PATH_GLSLP_EXTENSION);
}
if (video_driver_test_all_flags(GFX_CTX_FLAGS_SHADERS_GLSL))
filter += QLatin1Literal(" *") + file_path_str(FILE_PATH_GLSLP_EXTENSION);
{
gfx_ctx_flags_t flags;
if (video_driver_get_all_flags(&flags, GFX_CTX_FLAGS_SHADERS_SLANG))
filter += QLatin1Literal(" *") + file_path_str(FILE_PATH_SLANGP_EXTENSION);
}
if (video_driver_test_all_flags(GFX_CTX_FLAGS_SHADERS_SLANG))
filter += QLatin1Literal(" *") + file_path_str(FILE_PATH_SLANGP_EXTENSION);
filter += ")";
@ -512,7 +503,7 @@ void ShaderParamsDialog::onShaderLoadPresetClicked()
pathArray = path.toUtf8();
pathData = pathArray.constData();
type = video_shader_parse_type(pathData, RARCH_SHADER_NONE);
type = video_shader_parse_type(pathData);
menu_shader_manager_set_preset(menu_shader, type, pathData);
}
@ -626,23 +617,14 @@ void ShaderParamsDialog::onShaderAddPassClicked()
filter = "Shader (";
/* NOTE: Maybe we should have a way to get a list of all shader types instead of hard-coding this? */
{
gfx_ctx_flags_t flags;
if (video_driver_get_all_flags(&flags, GFX_CTX_FLAGS_SHADERS_CG))
filter += QLatin1Literal(" *.cg");
}
if (video_driver_test_all_flags(GFX_CTX_FLAGS_SHADERS_CG))
filter += QLatin1Literal(" *.cg");
{
gfx_ctx_flags_t flags;
if (video_driver_get_all_flags(&flags, GFX_CTX_FLAGS_SHADERS_GLSL))
filter += QLatin1Literal(" *.glsl");
}
if (video_driver_test_all_flags(GFX_CTX_FLAGS_SHADERS_GLSL))
filter += QLatin1Literal(" *.glsl");
{
gfx_ctx_flags_t flags;
if (video_driver_get_all_flags(&flags, GFX_CTX_FLAGS_SHADERS_SLANG))
filter += QLatin1Literal(" *.slang");
}
if (video_driver_test_all_flags(GFX_CTX_FLAGS_SHADERS_SLANG))
filter += QLatin1Literal(" *.slang");
filter += ")";