ShuriZma
/
RetroArch
mirror of https://github.com/libretro/RetroArch.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

refactor some video_shader_parse functions 

- 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)
{

2
gfx/drivers/gl_core.c
View File

@ -781,7 +781,7 @@ static bool gl_core_init_filter_chain(gl_core_t *gl)
{
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)
{

29
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,33 +1189,24 @@ 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;
}
}
{
gfx_ctx_flags_t flags;
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;
}
}
{
gfx_ctx_flags_t flags;
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_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);

15
list_special.c
View File

@ -98,32 +98,23 @@ struct string_list *dir_list_new_special(const char *input_dir,
attr.i = 0;
{
gfx_ctx_flags_t flags;
if (video_driver_get_all_flags(&flags, GFX_CTX_FLAGS_SHADERS_CG))
if (video_driver_test_all_flags(GFX_CTX_FLAGS_SHADERS_CG))
{
string_list_append(str_list, "cgp", attr);
string_list_append(str_list, "cg", attr);
}
}
{
gfx_ctx_flags_t flags;
if (video_driver_get_all_flags(&flags, GFX_CTX_FLAGS_SHADERS_GLSL))
if (video_driver_test_all_flags(GFX_CTX_FLAGS_SHADERS_GLSL))
{
string_list_append(str_list, "glslp", attr);
string_list_append(str_list, "glsl", attr);
}
}
{
gfx_ctx_flags_t flags;
if (video_driver_get_all_flags(&flags, GFX_CTX_FLAGS_SHADERS_SLANG))
if (video_driver_test_all_flags(GFX_CTX_FLAGS_SHADERS_SLANG))
{
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, "|");
string_list_free(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;

31
menu/menu_displaylist.c
View File

@ -6804,10 +6804,7 @@ bool menu_displaylist_ctl(enum menu_displaylist_ctl_state type,
MENU_SETTING_ACTION, 0, 0))
count++;
{
gfx_ctx_flags_t flags;
if (video_driver_get_all_flags(&flags, GFX_CTX_FLAGS_SHADERS_CG))
if (video_driver_test_all_flags(GFX_CTX_FLAGS_SHADERS_CG))
{
if (menu_entries_append_enum(info->list,
msg_hash_to_str(MENU_ENUM_LABEL_VALUE_UPDATE_CG_SHADERS),
@ -6816,11 +6813,8 @@ bool menu_displaylist_ctl(enum menu_displaylist_ctl_state type,
MENU_SETTING_ACTION, 0, 0))
count++;
}
}
{
gfx_ctx_flags_t flags;
if (video_driver_get_all_flags(&flags, GFX_CTX_FLAGS_SHADERS_GLSL))
if (video_driver_test_all_flags(GFX_CTX_FLAGS_SHADERS_GLSL))
{
if (menu_entries_append_enum(info->list,
msg_hash_to_str(MENU_ENUM_LABEL_VALUE_UPDATE_GLSL_SHADERS),
@ -6829,11 +6823,8 @@ bool menu_displaylist_ctl(enum menu_displaylist_ctl_state type,
MENU_SETTING_ACTION, 0, 0))
count++;
}
}
{
gfx_ctx_flags_t flags;
if (video_driver_get_all_flags(&flags, GFX_CTX_FLAGS_SHADERS_SLANG))
if (video_driver_test_all_flags(GFX_CTX_FLAGS_SHADERS_SLANG))
{
if (menu_entries_append_enum(info->list,
msg_hash_to_str(MENU_ENUM_LABEL_VALUE_UPDATE_SLANG_SHADERS),
@ -6842,7 +6833,6 @@ bool menu_displaylist_ctl(enum menu_displaylist_ctl_state type,
MENU_SETTING_ACTION, 0, 0))
count++;
}
}
#endif
}
@ -7474,38 +7464,29 @@ bool menu_displaylist_ctl(enum menu_displaylist_ctl_state type,
else if (type == DISPLAYLIST_SHADER_PASS)
info->type_default = FILE_TYPE_SHADER;
{
gfx_ctx_flags_t flags;
if (video_driver_get_all_flags(&flags, GFX_CTX_FLAGS_SHADERS_CG))
if (video_driver_test_all_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);
}
}
{
gfx_ctx_flags_t flags;
if (video_driver_get_all_flags(&flags, GFX_CTX_FLAGS_SHADERS_GLSL))
if (video_driver_test_all_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);
}
}
{
gfx_ctx_flags_t flags;
if (video_driver_get_all_flags(&flags, GFX_CTX_FLAGS_SHADERS_SLANG))
if (video_driver_test_all_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);
}
}
string_list_join_concat(new_exts, sizeof(new_exts), str_list, "|");
if (!string_is_empty(info->exts))

28
menu/menu_setting.c
View File

@ -8940,10 +8940,7 @@ 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);
{
gfx_ctx_flags_t flags;
if (video_driver_get_all_flags(&flags, GFX_CTX_FLAGS_CUSTOMIZABLE_SWAPCHAIN_IMAGES))
if (video_driver_test_all_flags(GFX_CTX_FLAGS_CUSTOMIZABLE_SWAPCHAIN_IMAGES))
{
CONFIG_UINT(
list, list_info,
@ -8959,12 +8956,8 @@ static bool setting_append_list(
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);
}
}
{
gfx_ctx_flags_t flags;
if (video_driver_get_all_flags(&flags, GFX_CTX_FLAGS_HARD_SYNC))
if (video_driver_test_all_flags(GFX_CTX_FLAGS_HARD_SYNC))
{
CONFIG_BOOL(
list, list_info,
@ -8996,12 +8989,8 @@ static bool setting_append_list(
(*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);
}
}
{
gfx_ctx_flags_t flags;
if (video_driver_get_all_flags(&flags, GFX_CTX_FLAGS_ADAPTIVE_VSYNC))
if (video_driver_test_all_flags(GFX_CTX_FLAGS_ADAPTIVE_VSYNC))
{
CONFIG_BOOL(
list, list_info,
@ -9019,7 +9008,6 @@ static bool setting_append_list(
SD_FLAG_NONE
);
}
}
CONFIG_UINT(
list, list_info,
@ -9037,10 +9025,7 @@ static bool setting_append_list(
SETTINGS_DATA_LIST_CURRENT_ADD_FLAGS(list, list_info, SD_FLAG_LAKKA_ADVANCED);
#if !defined(RARCH_MOBILE)
{
gfx_ctx_flags_t flags;
if (video_driver_get_all_flags(&flags, GFX_CTX_FLAGS_BLACK_FRAME_INSERTION))
if (video_driver_test_all_flags(GFX_CTX_FLAGS_BLACK_FRAME_INSERTION))
{
CONFIG_BOOL(
list, list_info,
@ -9059,7 +9044,6 @@ static bool setting_append_list(
);
SETTINGS_DATA_LIST_CURRENT_ADD_FLAGS(list, list_info, SD_FLAG_LAKKA_ADVANCED);
}
}
#endif
END_SUB_GROUP(list, list_info, parent_group);
START_SUB_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);

32
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))
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))
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))
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))
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))
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))
if (video_driver_test_all_flags(GFX_CTX_FLAGS_SHADERS_SLANG))
filter += QLatin1Literal(" *.slang");
}
filter += ")";