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

Faster shader capabilities queries

This commit is contained in:
libretroadmin 2024-12-22 21:58:51 +01:00
parent c09fd38c1d
commit b3e5c578b3
9 changed files with 274 additions and 183 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

6
command.c
View File

@ -1853,7 +1853,11 @@ bool command_set_shader(command_t *cmd, const char *arg)
if (!string_is_empty(arg))
{
if (!video_shader_is_supported(type))
gfx_ctx_flags_t flags;
flags.flags = 0;
video_context_driver_get_flags(&flags);
if (!BIT32_GET(flags.flags, video_shader_type_to_flag(type)))
return false;
/* rebase on shader directory */

7
gfx/drivers/gl2.c
View File

@ -2796,6 +2796,9 @@ static enum rarch_shader_type gl2_get_fallback_shader_type(enum rarch_shader_typ
{
#if defined(HAVE_GLSL) || defined(HAVE_CG)
int i;
gfx_ctx_flags_t flags;
flags.flags = 0;
video_context_driver_get_flags(&flags);
if (type != RARCH_SHADER_CG && type != RARCH_SHADER_GLSL)
{
@ -2811,7 +2814,7 @@ static enum rarch_shader_type gl2_get_fallback_shader_type(enum rarch_shader_typ
{
case RARCH_SHADER_CG:
#ifdef HAVE_CG
if (video_shader_is_supported(type))
if (BIT32_GET(flags.flags, GFX_CTX_FLAGS_SHADERS_CG))
return type;
#endif
type = RARCH_SHADER_GLSL;
@ -2819,7 +2822,7 @@ static enum rarch_shader_type gl2_get_fallback_shader_type(enum rarch_shader_typ
case RARCH_SHADER_GLSL:
#ifdef HAVE_GLSL
if (video_shader_is_supported(type))
if (BIT32_GET(flags.flags, GFX_CTX_FLAGS_SHADERS_GLSL))
return type;
#endif
type = RARCH_SHADER_CG;

112
gfx/video_shader_parse.c
View File

@ -378,24 +378,36 @@ static void video_shader_replace_wildcards(char *s, size_t len, char *in_preset_
}
break;
case RARCH_WILDCARD_VIDEO_DRIVER_SHADER_EXT:
if (video_shader_is_supported(RARCH_SHADER_CG))
replace_len = strlcpy(replace_text, "cg", sizeof(replace_text));
else if (video_shader_is_supported(RARCH_SHADER_GLSL))
replace_len = strlcpy(replace_text, "glsl", sizeof(replace_text));
else if (video_shader_is_supported(RARCH_SHADER_SLANG))
replace_len = strlcpy(replace_text, "slang", sizeof(replace_text));
else
replace_text[0] = '\0';
{
gfx_ctx_flags_t flags;
flags.flags = 0;
video_context_driver_get_flags(&flags);
if (BIT32_GET(flags.flags, GFX_CTX_FLAGS_SHADERS_SLANG))
replace_len = strlcpy(replace_text, "slang", sizeof(replace_text));
else if (BIT32_GET(flags.flags, GFX_CTX_FLAGS_SHADERS_GLSL))
replace_len = strlcpy(replace_text, "glsl", sizeof(replace_text));
else if (BIT32_GET(flags.flags, GFX_CTX_FLAGS_SHADERS_CG))
replace_len = strlcpy(replace_text, "cg", sizeof(replace_text));
else
replace_text[0] = '\0';
}
break;
case RARCH_WILDCARD_VIDEO_DRIVER_PRESET_EXT:
if (video_shader_is_supported(RARCH_SHADER_CG))
replace_len = strlcpy(replace_text, "cgp", sizeof(replace_text));
else if (video_shader_is_supported(RARCH_SHADER_GLSL))
replace_len = strlcpy(replace_text, "glslp", sizeof(replace_text));
else if (video_shader_is_supported(RARCH_SHADER_SLANG))
replace_len = strlcpy(replace_text, "slangp", sizeof(replace_text));
else
replace_text[0] = '\0';
{
gfx_ctx_flags_t flags;
flags.flags = 0;
video_context_driver_get_flags(&flags);
if (BIT32_GET(flags.flags, GFX_CTX_FLAGS_SHADERS_SLANG))
replace_len = strlcpy(replace_text, "slangp", sizeof(replace_text));
else if (BIT32_GET(flags.flags, GFX_CTX_FLAGS_SHADERS_GLSL))
replace_len = strlcpy(replace_text, "glslp", sizeof(replace_text));
else if (BIT32_GET(flags.flags, GFX_CTX_FLAGS_SHADERS_CG))
replace_len = strlcpy(replace_text, "cgp", sizeof(replace_text));
else
replace_text[0] = '\0';
}
break;
default:
replace_text[0] = '\0';
@ -455,11 +467,10 @@ static void video_shader_gather_reference_path_list(
struct path_linked_list *ref_tmp = (struct path_linked_list*)conf->references;
while (ref_tmp)
{
char* reference_preset_path = (char*)malloc(PATH_MAX_LENGTH);
char *reference_preset_path = (char*)malloc(PATH_MAX_LENGTH);
/* Get the absolute path and replace wildcards in the path */
fill_pathname_expanded_and_absolute(reference_preset_path, PATH_MAX_LENGTH, conf->path, ref_tmp->path);
video_shader_replace_wildcards(reference_preset_path, PATH_MAX_LENGTH, conf->path);
video_shader_gather_reference_path_list(in_path_linked_list, reference_preset_path, reference_depth + 1);
free(reference_preset_path);
@ -2371,41 +2382,23 @@ const char *video_shader_type_to_str(enum rarch_shader_type type)
return "???";
}
/**
* video_shader_is_supported:
* Tests if a shader type is supported.
* This is only accurate once the context driver was initialized.
* @return true on success, otherwise false on failure.
**/
bool video_shader_is_supported(enum rarch_shader_type type)
enum display_flags video_shader_type_to_flag(enum rarch_shader_type type)
{
gfx_ctx_flags_t flags;
enum display_flags testflag = GFX_CTX_FLAGS_NONE;
flags.flags = 0;
switch (type)
{
case RARCH_SHADER_SLANG:
testflag = GFX_CTX_FLAGS_SHADERS_SLANG;
break;
return GFX_CTX_FLAGS_SHADERS_SLANG;
case RARCH_SHADER_GLSL:
testflag = GFX_CTX_FLAGS_SHADERS_GLSL;
break;
return GFX_CTX_FLAGS_SHADERS_GLSL;
case RARCH_SHADER_CG:
testflag = GFX_CTX_FLAGS_SHADERS_CG;
break;
return GFX_CTX_FLAGS_SHADERS_CG;
case RARCH_SHADER_HLSL:
testflag = GFX_CTX_FLAGS_SHADERS_HLSL;
break;
return GFX_CTX_FLAGS_SHADERS_HLSL;
case RARCH_SHADER_NONE:
default:
return false;
break;
}
video_context_driver_get_flags(&flags);
return BIT32_GET(flags.flags, testflag);
return GFX_CTX_FLAGS_NONE;
}
const char *video_shader_get_preset_extension(enum rarch_shader_type type)
@ -2426,19 +2419,6 @@ const char *video_shader_get_preset_extension(enum rarch_shader_type type)
return NULL;
}
bool video_shader_any_supported(void)
{
gfx_ctx_flags_t flags;
flags.flags = 0;
video_context_driver_get_flags(&flags);
return
BIT32_GET(flags.flags, GFX_CTX_FLAGS_SHADERS_SLANG)
|| BIT32_GET(flags.flags, GFX_CTX_FLAGS_SHADERS_GLSL)
|| BIT32_GET(flags.flags, GFX_CTX_FLAGS_SHADERS_CG)
|| BIT32_GET(flags.flags, GFX_CTX_FLAGS_SHADERS_HLSL);
}
enum rarch_shader_type video_shader_get_type_from_ext(
const char *ext, bool *is_preset)
{
@ -2795,6 +2775,8 @@ static bool video_shader_load_shader_preset_internal(
const char *special_name)
{
int i;
gfx_ctx_flags_t flags;
flags.flags = 0;
static enum rarch_shader_type types[] =
{
@ -2802,10 +2784,18 @@ static bool video_shader_load_shader_preset_internal(
* only important for video drivers with multiple shader backends */
RARCH_SHADER_GLSL, RARCH_SHADER_SLANG, RARCH_SHADER_CG, RARCH_SHADER_HLSL
};
static enum rarch_shader_type types_trans[] =
{
/* Shader preset priority, highest to lowest
* only important for video drivers with multiple shader backends */
GFX_CTX_FLAGS_SHADERS_GLSL, GFX_CTX_FLAGS_SHADERS_SLANG, GFX_CTX_FLAGS_SHADERS_CG, GFX_CTX_FLAGS_SHADERS_HLSL
};
video_context_driver_get_flags(&flags);
for (i = 0; i < (int)ARRAY_SIZE(types); i++)
{
if (!video_shader_is_supported(types[i]))
if (!BIT32_GET(flags.flags, types_trans[i]))
continue;
/* Concatenate strings into full paths */
@ -2849,7 +2839,7 @@ static bool video_shader_load_shader_preset_internal(
* For compatibility purposes with versions 1.8.7 and older, the presets
* subdirectory on the Video Shader path is used as a fallback directory.
*
* Note: Uses video_shader_is_supported() which only works after
* Note: Uses video_context_driver_get_flags() which only works after
* context driver initialization.
*
* Returns: false if there was an error or no action was performed.
@ -3122,9 +3112,13 @@ const char *video_shader_get_current_shader_preset(void)
if ( (video_st->flags & VIDEO_FLAG_SHADER_PRESETS_NEED_RELOAD)
&& !cli_shader_disable)
{
gfx_ctx_flags_t flags;
flags.flags = 0;
video_context_driver_get_flags(&flags);
video_st->flags &= ~VIDEO_FLAG_SHADER_PRESETS_NEED_RELOAD;
if (video_shader_is_supported(
if (BIT32_GET(flags.flags,
video_shader_parse_type(video_st->cli_shader_path)))
strlcpy(runloop_st->runtime_shader_preset_path,
video_st->cli_shader_path,

4
gfx/video_shader_parse.h
View File

@ -246,9 +246,7 @@ bool video_shader_write_preset(const char *path,
enum rarch_shader_type video_shader_get_type_from_ext(const char *ext, bool *is_preset);
bool video_shader_is_supported(enum rarch_shader_type type);
bool video_shader_any_supported(void);
enum display_flags video_shader_type_to_flag(enum rarch_shader_type type);
bool video_shader_check_for_changes(void);

95
menu/menu_displaylist.c
View File

@ -4014,16 +4014,26 @@ static int menu_displaylist_parse_load_content_settings(
#endif
#if defined(HAVE_CG) || defined(HAVE_GLSL) || defined(HAVE_SLANG) || defined(HAVE_HLSL)
if (video_shader_any_supported())
{
if (settings->bools.quick_menu_show_shaders && !settings->bools.kiosk_mode_enable)
gfx_ctx_flags_t flags;
flags.flags = 0;
video_context_driver_get_flags(&flags);
if (
BIT32_GET(flags.flags, GFX_CTX_FLAGS_SHADERS_SLANG)
|| BIT32_GET(flags.flags, GFX_CTX_FLAGS_SHADERS_GLSL)
|| BIT32_GET(flags.flags, GFX_CTX_FLAGS_SHADERS_CG)
|| BIT32_GET(flags.flags, GFX_CTX_FLAGS_SHADERS_HLSL))
{
if (menu_entries_append(list,
msg_hash_to_str(MENU_ENUM_LABEL_VALUE_SHADER_OPTIONS),
msg_hash_to_str(MENU_ENUM_LABEL_SHADER_OPTIONS),
MENU_ENUM_LABEL_SHADER_OPTIONS,
MENU_SETTING_ACTION, 0, 0, NULL))
count++;
if (settings->bools.quick_menu_show_shaders && !settings->bools.kiosk_mode_enable)
{
if (menu_entries_append(list,
msg_hash_to_str(MENU_ENUM_LABEL_VALUE_SHADER_OPTIONS),
msg_hash_to_str(MENU_ENUM_LABEL_SHADER_OPTIONS),
MENU_ENUM_LABEL_SHADER_OPTIONS,
MENU_SETTING_ACTION, 0, 0, NULL))
count++;
}
}
}
#endif
@ -11227,12 +11237,22 @@ unsigned menu_displaylist_build_list(
}
#if defined(HAVE_CG) || defined(HAVE_GLSL) || defined(HAVE_SLANG) || defined(HAVE_HLSL)
if (video_shader_any_supported())
{
if (MENU_DISPLAYLIST_PARSE_SETTINGS_ENUM(list,
MENU_ENUM_LABEL_QUICK_MENU_SHOW_SHADERS,
PARSE_ONLY_BOOL, false) == 0)
count++;
gfx_ctx_flags_t flags;
flags.flags = 0;
video_context_driver_get_flags(&flags);
if (
BIT32_GET(flags.flags, GFX_CTX_FLAGS_SHADERS_SLANG)
|| BIT32_GET(flags.flags, GFX_CTX_FLAGS_SHADERS_GLSL)
|| BIT32_GET(flags.flags, GFX_CTX_FLAGS_SHADERS_CG)
|| BIT32_GET(flags.flags, GFX_CTX_FLAGS_SHADERS_HLSL))
{
if (MENU_DISPLAYLIST_PARSE_SETTINGS_ENUM(list,
MENU_ENUM_LABEL_QUICK_MENU_SHOW_SHADERS,
PARSE_ONLY_BOOL, false) == 0)
count++;
}
}
#endif
@ -14624,6 +14644,11 @@ bool menu_displaylist_ctl(enum menu_displaylist_ctl_state type,
case DISPLAYLIST_OPTIONS:
menu_entries_clear(info->list);
{
#if defined(HAVE_CG) || defined(HAVE_GLSL) || defined(HAVE_SLANG) || defined(HAVE_HLSL)
gfx_ctx_flags_t flags;
flags.flags = 0;
video_context_driver_get_flags(&flags);
#endif
#ifdef HAVE_LAKKA
if (menu_entries_append(info->list,
msg_hash_to_str(MENU_ENUM_LABEL_VALUE_UPDATE_LAKKA),
@ -14806,7 +14831,7 @@ bool menu_displaylist_ctl(enum menu_displaylist_ctl_state type,
count++;
#if defined(HAVE_CG) || defined(HAVE_GLSL) || defined(HAVE_SLANG) || defined(HAVE_HLSL)
if (video_shader_is_supported(RARCH_SHADER_CG))
if (BIT32_GET(flags.flags, GFX_CTX_FLAGS_SHADERS_CG))
{
if (menu_entries_append(info->list,
msg_hash_to_str(MENU_ENUM_LABEL_VALUE_UPDATE_CG_SHADERS),
@ -14816,7 +14841,7 @@ bool menu_displaylist_ctl(enum menu_displaylist_ctl_state type,
count++;
}
if (video_shader_is_supported(RARCH_SHADER_GLSL))
if (BIT32_GET(flags.flags, GFX_CTX_FLAGS_SHADERS_GLSL))
{
if (menu_entries_append(info->list,
msg_hash_to_str(MENU_ENUM_LABEL_VALUE_UPDATE_GLSL_SHADERS),
@ -14826,7 +14851,7 @@ bool menu_displaylist_ctl(enum menu_displaylist_ctl_state type,
count++;
}
if (video_shader_is_supported(RARCH_SHADER_SLANG))
if (BIT32_GET(flags.flags, GFX_CTX_FLAGS_SHADERS_SLANG))
{
if (menu_entries_append(info->list,
msg_hash_to_str(MENU_ENUM_LABEL_VALUE_UPDATE_SLANG_SHADERS),
@ -15140,22 +15165,27 @@ bool menu_displaylist_ctl(enum menu_displaylist_ctl_state type,
#if defined(HAVE_CG) || defined(HAVE_GLSL) || defined(HAVE_SLANG) || defined(HAVE_HLSL)
{
char new_exts[PATH_MAX_LENGTH];
size_t _len = 0;
new_exts[0] = '\0';
gfx_ctx_flags_t flags;
size_t _len = 0;
new_exts[0] = '\0';
flags.flags = 0;
filebrowser_clear_type();
video_context_driver_get_flags(&flags);
switch (type)
{
case DISPLAYLIST_SHADER_PRESET:
info->type_default = FILE_TYPE_SHADER_PRESET;
if (video_shader_is_supported(RARCH_SHADER_CG))
if (BIT32_GET(flags.flags, GFX_CTX_FLAGS_SHADERS_CG))
_len += strlcpy(new_exts + _len, "cgp", sizeof(new_exts) - _len);
if (video_shader_is_supported(RARCH_SHADER_GLSL))
if (BIT32_GET(flags.flags, GFX_CTX_FLAGS_SHADERS_GLSL))
{
if (new_exts[_len-1] != '\0')
_len += strlcpy(new_exts + _len, "|", sizeof(new_exts) - _len);
_len += strlcpy(new_exts + _len, "glslp", sizeof(new_exts) - _len);
}
if (video_shader_is_supported(RARCH_SHADER_SLANG))
if (BIT32_GET(flags.flags, GFX_CTX_FLAGS_SHADERS_SLANG))
{
if (new_exts[_len-1] != '\0')
_len += strlcpy(new_exts + _len, "|", sizeof(new_exts) - _len);
@ -15165,15 +15195,15 @@ bool menu_displaylist_ctl(enum menu_displaylist_ctl_state type,
case DISPLAYLIST_SHADER_PASS:
info->type_default = FILE_TYPE_SHADER;
if (video_shader_is_supported(RARCH_SHADER_CG))
if (BIT32_GET(flags.flags, GFX_CTX_FLAGS_SHADERS_CG))
_len += strlcpy(new_exts + _len, "cg", sizeof(new_exts) - _len);
if (video_shader_is_supported(RARCH_SHADER_GLSL))
if (BIT32_GET(flags.flags, GFX_CTX_FLAGS_SHADERS_GLSL))
{
if (new_exts[_len-1] != '\0')
_len += strlcpy(new_exts + _len, "|", sizeof(new_exts) - _len);
_len += strlcpy(new_exts + _len, "glsl", sizeof(new_exts) - _len);
}
if (video_shader_is_supported(RARCH_SHADER_SLANG))
if (BIT32_GET(flags.flags, GFX_CTX_FLAGS_SHADERS_SLANG))
{
if (new_exts[_len-1] != '\0')
_len += strlcpy(new_exts + _len, "|", sizeof(new_exts) - _len);
@ -15196,20 +15226,27 @@ bool menu_displaylist_ctl(enum menu_displaylist_ctl_state type,
menu_entries_clear(info->list);
#if defined(HAVE_CG) || defined(HAVE_GLSL) || defined(HAVE_SLANG) || defined(HAVE_HLSL)
{
gfx_ctx_flags_t flags;
char new_exts[PATH_MAX_LENGTH];
size_t _len = 0;
new_exts[0] = '\0';
size_t _len = 0;
flags.flags = 0;
new_exts[0] = '\0';
filebrowser_clear_type();
video_context_driver_get_flags(&flags);
info->type_default = FILE_TYPE_SHADER_PRESET;
if (video_shader_is_supported(RARCH_SHADER_CG))
if (BIT32_GET(flags.flags, GFX_CTX_FLAGS_SHADERS_CG))
_len += strlcpy(new_exts + _len, "cgp", sizeof(new_exts) - _len);
if (video_shader_is_supported(RARCH_SHADER_GLSL))
if (BIT32_GET(flags.flags, GFX_CTX_FLAGS_SHADERS_GLSL))
{
if (new_exts[_len-1] != '\0')
_len += strlcpy(new_exts + _len, "|", sizeof(new_exts) - _len);
_len += strlcpy(new_exts + _len, "glslp", sizeof(new_exts) - _len);
}
if (video_shader_is_supported(RARCH_SHADER_SLANG))
if (BIT32_GET(flags.flags, GFX_CTX_FLAGS_SHADERS_SLANG))
{
if (new_exts[_len-1] != '\0')
_len += strlcpy(new_exts + _len, "|", sizeof(new_exts) - _len);

74
menu/menu_driver.c
View File

@ -2704,6 +2704,7 @@ static void menu_driver_get_last_shader_path_int(
const char *shader_dir, const char *shader_file_name,
const char **dir_out, const char **file_name_out)
{
gfx_ctx_flags_t flags;
bool remember_last_dir = settings->bools.video_shader_remember_last_dir;
const char *video_shader_dir = settings->paths.directory_video_shader;
@ -2711,6 +2712,9 @@ static void menu_driver_get_last_shader_path_int(
if (file_name_out)
*file_name_out = NULL;
flags.flags = 0;
video_context_driver_get_flags(&flags);
/* If any of the following are true:
* - Directory caching is disabled
* - No directory has been cached
@ -2722,7 +2726,7 @@ static void menu_driver_get_last_shader_path_int(
|| (type == RARCH_SHADER_NONE)
|| string_is_empty(shader_dir)
|| !path_is_directory(shader_dir)
|| !video_shader_is_supported(type))
|| !BIT32_GET(flags.flags, video_shader_type_to_flag(type)))
{
if (dir_out)
*dir_out = video_shader_dir;
@ -2950,7 +2954,6 @@ static bool menu_shader_manager_save_preset_internal(
{
size_t _len;
char fullname[NAME_MAX_LENGTH];
const char *preset_ext = NULL;
bool ret = false;
enum rarch_shader_type type = RARCH_SHADER_NONE;
char *preset_path = NULL;
@ -2960,13 +2963,13 @@ static bool menu_shader_manager_save_preset_internal(
if ((type = menu_shader_manager_get_type(shader)) == RARCH_SHADER_NONE)
return false;
preset_ext = video_shader_get_preset_extension(type);
if (!string_is_empty(basename))
_len = strlcpy(fullname, basename, sizeof(fullname));
else
_len = strlcpy(fullname, "retroarch", sizeof(fullname));
strlcpy(fullname + _len, preset_ext, sizeof(fullname) - _len);
strlcpy(fullname + _len,
video_shader_get_preset_extension(type),
sizeof(fullname) - _len);
if (path_is_absolute(fullname))
{
@ -3081,10 +3084,14 @@ static bool menu_shader_manager_operate_auto_preset(
settings_t *settings = config_get_ptr();
bool video_shader_preset_save_reference_enable = settings->bools.video_shader_preset_save_reference_enable;
struct retro_system_info *sysinfo = &runloop_state_get_ptr()->system.info;
static enum rarch_shader_type shader_types[] =
static enum rarch_shader_type shader_types[] =
{
RARCH_SHADER_GLSL, RARCH_SHADER_SLANG, RARCH_SHADER_CG
};
static enum rarch_shader_type shader_types_flags[] =
{
GFX_CTX_FLAGS_SHADERS_GLSL, GFX_CTX_FLAGS_SHADERS_SLANG, GFX_CTX_FLAGS_SHADERS_CG
};
const char *core_name = sysinfo ? sysinfo->library_name : NULL;
const char *rarch_path_basename = path_get(RARCH_PATH_BASENAME);
const char *auto_preset_dirs[3] = {0};
@ -3166,12 +3173,14 @@ static bool menu_shader_manager_operate_auto_preset(
/* remove all supported auto-shaders of given type */
char *end;
size_t i, j, m;
char preset_path[PATH_MAX_LENGTH];
gfx_ctx_flags_t flags;
/* n = amount of relevant shader presets found
* m = amount of successfully deleted shader presets */
size_t n = m = 0;
size_t n = m = 0;
flags.flags = 0;
video_context_driver_get_flags(&flags);
for (i = 0; i < ARRAY_SIZE(auto_preset_dirs); i++)
{
@ -3185,13 +3194,10 @@ static bool menu_shader_manager_operate_auto_preset(
for (j = 0; j < ARRAY_SIZE(shader_types); j++)
{
const char *preset_ext;
if (!video_shader_is_supported(shader_types[j]))
if (!(BIT32_GET(flags.flags, shader_types_flags[j])))
continue;
preset_ext = video_shader_get_preset_extension(shader_types[j]);
strlcpy(end, preset_ext, sizeof(preset_path) - (end - preset_path));
strlcpy(end, video_shader_get_preset_extension(shader_types[j]),
sizeof(preset_path) - (end - preset_path));
if (path_is_valid(preset_path))
{
@ -3215,9 +3221,13 @@ static bool menu_shader_manager_operate_auto_preset(
/* test if any supported auto-shaders of given type exists */
char *end;
size_t i, j;
gfx_ctx_flags_t flags;
char preset_path[PATH_MAX_LENGTH];
flags.flags = 0;
video_context_driver_get_flags(&flags);
for (i = 0; i < ARRAY_SIZE(auto_preset_dirs); i++)
{
size_t _len2;
@ -3230,13 +3240,11 @@ static bool menu_shader_manager_operate_auto_preset(
for (j = 0; j < ARRAY_SIZE(shader_types); j++)
{
const char *preset_ext;
if (!video_shader_is_supported(shader_types[j]))
if (!(BIT32_GET(flags.flags, shader_types[j])))
continue;
preset_ext = video_shader_get_preset_extension(shader_types[j]);
strlcpy(end, preset_ext, sizeof(preset_path) - (end - preset_path));
strlcpy(end, video_shader_get_preset_extension(shader_types[j]),
sizeof(preset_path) - (end - preset_path));
if (path_is_valid(preset_path))
return true;
@ -6817,7 +6825,15 @@ bool menu_driver_ctl(enum rarch_menu_ctl_state state, void *data)
#if defined(HAVE_CG) || defined(HAVE_GLSL) || defined(HAVE_SLANG) || defined(HAVE_HLSL)
struct video_shader *menu_shader_get(void)
{
if (video_shader_any_supported())
gfx_ctx_flags_t flags;
flags.flags = 0;
video_context_driver_get_flags(&flags);
if (
BIT32_GET(flags.flags, GFX_CTX_FLAGS_SHADERS_SLANG)
|| BIT32_GET(flags.flags, GFX_CTX_FLAGS_SHADERS_GLSL)
|| BIT32_GET(flags.flags, GFX_CTX_FLAGS_SHADERS_CG)
|| BIT32_GET(flags.flags, GFX_CTX_FLAGS_SHADERS_HLSL))
{
video_driver_state_t *video_st = video_state_get_ptr();
if (video_st)
@ -6833,6 +6849,7 @@ struct video_shader *menu_shader_get(void)
**/
bool menu_shader_manager_init(void)
{
gfx_ctx_flags_t flags;
video_driver_state_t *video_st = video_state_get_ptr();
enum rarch_shader_type type = RARCH_SHADER_NONE;
bool ret = true;
@ -6856,10 +6873,7 @@ bool menu_shader_manager_init(void)
menu_shader_manager_free();
menu_shader = (struct video_shader*)
calloc(1, sizeof(*menu_shader));
if (!menu_shader)
if (!(menu_shader = (struct video_shader*)calloc(1, sizeof(*menu_shader))))
{
ret = false;
goto end;
@ -6868,10 +6882,12 @@ bool menu_shader_manager_init(void)
if (string_is_empty(path_shader))
goto end;
type = video_shader_get_type_from_ext(path_get_extension(path_shader),
&is_preset);
type = video_shader_get_type_from_ext(
path_get_extension(path_shader), &is_preset);
flags.flags = 0;
video_context_driver_get_flags(&flags);
if (!video_shader_is_supported(type))
if (!BIT32_GET(flags.flags, video_shader_type_to_flag(type)))
{
ret = false;
goto end;

124
menu/menu_setting.c
View File

@ -14269,22 +14269,32 @@ static bool setting_append_list(
* requires an explicit guard to prevent display
* on unsupported platforms */
#if defined(HAVE_CG) || defined(HAVE_GLSL) || defined(HAVE_SLANG) || defined(HAVE_HLSL)
if (video_shader_any_supported())
{
CONFIG_UINT(
list, list_info,
&settings->uints.video_shader_delay,
MENU_ENUM_LABEL_VIDEO_SHADER_DELAY,
MENU_ENUM_LABEL_VALUE_VIDEO_SHADER_DELAY,
DEFAULT_SHADER_DELAY,
&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, 0, 1, true, false);
SETTINGS_DATA_LIST_CURRENT_ADD_FLAGS(list, list_info, SD_FLAG_ADVANCED);
gfx_ctx_flags_t flags;
flags.flags = 0;
video_context_driver_get_flags(&flags);
if (
BIT32_GET(flags.flags, GFX_CTX_FLAGS_SHADERS_SLANG)
|| BIT32_GET(flags.flags, GFX_CTX_FLAGS_SHADERS_GLSL)
|| BIT32_GET(flags.flags, GFX_CTX_FLAGS_SHADERS_CG)
|| BIT32_GET(flags.flags, GFX_CTX_FLAGS_SHADERS_HLSL))
{
CONFIG_UINT(
list, list_info,
&settings->uints.video_shader_delay,
MENU_ENUM_LABEL_VIDEO_SHADER_DELAY,
MENU_ENUM_LABEL_VALUE_VIDEO_SHADER_DELAY,
DEFAULT_SHADER_DELAY,
&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, 0, 1, true, false);
SETTINGS_DATA_LIST_CURRENT_ADD_FLAGS(list, list_info, SD_FLAG_ADVANCED);
}
}
#endif
@ -19173,24 +19183,34 @@ static bool setting_append_list(
#if defined(HAVE_CG) || defined(HAVE_GLSL) || defined(HAVE_SLANG) || defined(HAVE_HLSL)
#ifdef HAVE_SHADERPIPELINE
if (video_shader_any_supported())
{
CONFIG_UINT(
list, list_info,
&settings->uints.menu_xmb_shader_pipeline,
MENU_ENUM_LABEL_XMB_RIBBON_ENABLE,
MENU_ENUM_LABEL_VALUE_XMB_RIBBON_ENABLE,
DEFAULT_MENU_SHADER_PIPELINE,
&group_info,
&subgroup_info,
parent_group,
general_write_handler,
general_read_handler);
(*list)[list_info->index - 1].action_ok = &setting_action_ok_uint;
(*list)[list_info->index - 1].get_string_representation =
&setting_get_string_representation_uint_xmb_shader_pipeline;
menu_settings_list_current_add_range(list, list_info, 0, XMB_SHADER_PIPELINE_LAST-1, 1, true, true);
(*list)[list_info->index - 1].ui_type = ST_UI_TYPE_UINT_COMBOBOX;
gfx_ctx_flags_t flags;
flags.flags = 0;
video_context_driver_get_flags(&flags);
if (
BIT32_GET(flags.flags, GFX_CTX_FLAGS_SHADERS_SLANG)
|| BIT32_GET(flags.flags, GFX_CTX_FLAGS_SHADERS_GLSL)
|| BIT32_GET(flags.flags, GFX_CTX_FLAGS_SHADERS_CG)
|| BIT32_GET(flags.flags, GFX_CTX_FLAGS_SHADERS_HLSL))
{
CONFIG_UINT(
list, list_info,
&settings->uints.menu_xmb_shader_pipeline,
MENU_ENUM_LABEL_XMB_RIBBON_ENABLE,
MENU_ENUM_LABEL_VALUE_XMB_RIBBON_ENABLE,
DEFAULT_MENU_SHADER_PIPELINE,
&group_info,
&subgroup_info,
parent_group,
general_write_handler,
general_read_handler);
(*list)[list_info->index - 1].action_ok = &setting_action_ok_uint;
(*list)[list_info->index - 1].get_string_representation =
&setting_get_string_representation_uint_xmb_shader_pipeline;
menu_settings_list_current_add_range(list, list_info, 0, XMB_SHADER_PIPELINE_LAST-1, 1, true, true);
(*list)[list_info->index - 1].ui_type = ST_UI_TYPE_UINT_COMBOBOX;
}
}
#endif
#endif
@ -21598,22 +21618,32 @@ static bool setting_append_list(
SD_FLAG_NONE);
#if defined(HAVE_CG) || defined(HAVE_GLSL) || defined(HAVE_SLANG) || defined(HAVE_HLSL)
if (video_shader_any_supported())
{
CONFIG_BOOL(
list, list_info,
&settings->bools.quick_menu_show_shaders,
MENU_ENUM_LABEL_QUICK_MENU_SHOW_SHADERS,
MENU_ENUM_LABEL_VALUE_QUICK_MENU_SHOW_SHADERS,
DEFAULT_QUICK_MENU_SHOW_SHADERS,
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);
gfx_ctx_flags_t flags;
flags.flags = 0;
video_context_driver_get_flags(&flags);
if (
BIT32_GET(flags.flags, GFX_CTX_FLAGS_SHADERS_SLANG)
|| BIT32_GET(flags.flags, GFX_CTX_FLAGS_SHADERS_GLSL)
|| BIT32_GET(flags.flags, GFX_CTX_FLAGS_SHADERS_CG)
|| BIT32_GET(flags.flags, GFX_CTX_FLAGS_SHADERS_HLSL))
{
CONFIG_BOOL(
list, list_info,
&settings->bools.quick_menu_show_shaders,
MENU_ENUM_LABEL_QUICK_MENU_SHOW_SHADERS,
MENU_ENUM_LABEL_VALUE_QUICK_MENU_SHOW_SHADERS,
DEFAULT_QUICK_MENU_SHOW_SHADERS,
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);
}
}
#endif

10
retroarch.c
View File

@ -2166,10 +2166,14 @@ struct string_list *dir_list_new_special(const char *input_dir,
case DIR_LIST_SHADERS:
#if defined(HAVE_CG) || defined(HAVE_GLSL) || defined(HAVE_SLANG) || defined(HAVE_HLSL)
{
gfx_ctx_flags_t flags;
size_t _len = 0;
flags.flags = 0;
ext_shaders[0] = '\0';
if (video_shader_is_supported(RARCH_SHADER_CG))
video_context_driver_get_flags(&flags);
if (BIT32_GET(flags.flags, GFX_CTX_FLAGS_SHADERS_CG))
{
_len += strlcpy(ext_shaders + _len, "cgp", sizeof(ext_shaders) - _len);
if (ext_shaders[_len-1] != '\0')
@ -2177,7 +2181,7 @@ struct string_list *dir_list_new_special(const char *input_dir,
_len += strlcpy(ext_shaders + _len, "cg", sizeof(ext_shaders) - _len);
}
if (video_shader_is_supported(RARCH_SHADER_GLSL))
if (BIT32_GET(flags.flags, GFX_CTX_FLAGS_SHADERS_GLSL))
{
if (ext_shaders[_len-1] != '\0')
_len += strlcpy(ext_shaders + _len, "|", sizeof(ext_shaders) - _len);
@ -2187,7 +2191,7 @@ struct string_list *dir_list_new_special(const char *input_dir,
_len += strlcpy(ext_shaders + _len, "glsl", sizeof(ext_shaders) - _len);
}
if (video_shader_is_supported(RARCH_SHADER_SLANG))
if (BIT32_GET(flags.flags, GFX_CTX_FLAGS_SHADERS_SLANG))
{
if (ext_shaders[_len-1] != '\0')
_len += strlcpy(ext_shaders + _len, "|", sizeof(ext_shaders) - _len);

25
ui/drivers/qt/qt_dialogs.cpp
View File

@ -1,4 +1,4 @@
#include <QCloseEvent>
#include <QCloseEvent>
#include <QSettings>
#include <QResizeEvent>
#include <QMessageBox>
@ -1726,6 +1726,7 @@ void ShaderParamsDialog::onShaderLoadPresetClicked()
{
QString path, filter;
QByteArray pathArray;
gfx_ctx_flags_t flags;
struct video_shader *menu_shader = NULL;
struct video_shader *video_shader = NULL;
const char *pathData = NULL;
@ -1735,7 +1736,6 @@ void ShaderParamsDialog::onShaderLoadPresetClicked()
const char *shader_preset_dir = settings->paths.directory_video_shader;
#else
const char *shader_preset_dir = NULL;
menu_driver_get_last_shader_preset_path(&shader_preset_dir, NULL);
#endif
@ -1746,21 +1746,24 @@ void ShaderParamsDialog::onShaderLoadPresetClicked()
filter.append("Shader Preset (");
flags.flags = 0;
video_context_driver_get_flags(&flags);
/* NOTE: Maybe we should have a way to get a list
* of all shader types instead of hard-coding this? */
if (video_shader_is_supported(RARCH_SHADER_CG))
if (BIT32_GET(flags.flags, GFX_CTX_FLAGS_SHADERS_CG))
{
filter.append(QLatin1String(" *"));
filter.append(".cgp");
}
if (video_shader_is_supported(RARCH_SHADER_GLSL))
if (BIT32_GET(flags.flags, GFX_CTX_FLAGS_SHADERS_GLSL))
{
filter.append(QLatin1String(" *"));
filter.append(".glslp");
}
if (video_shader_is_supported(RARCH_SHADER_SLANG))
if (BIT32_GET(flags.flags, GFX_CTX_FLAGS_SHADERS_SLANG))
{
filter.append(QLatin1String(" *"));
filter.append(".slangp");
@ -1883,6 +1886,7 @@ void ShaderParamsDialog::onShaderResetAllPasses()
void ShaderParamsDialog::onShaderAddPassClicked()
{
gfx_ctx_flags_t flags;
QString path, filter;
QByteArray pathArray;
struct video_shader *menu_shader = NULL;
@ -1905,15 +1909,16 @@ void ShaderParamsDialog::onShaderAddPassClicked()
filter.append("Shader (");
flags.flags = 0;
video_context_driver_get_flags(&flags);
/* NOTE: Maybe we should have a way to get a list
* of all shader types instead of hard-coding this? */
if (video_shader_is_supported(RARCH_SHADER_CG))
if (BIT32_GET(flags.flags, GFX_CTX_FLAGS_SHADERS_CG))
filter.append(QLatin1String(" *.cg"));
if (video_shader_is_supported(RARCH_SHADER_GLSL))
if (BIT32_GET(flags.flags, GFX_CTX_FLAGS_SHADERS_GLSL))
filter.append(QLatin1String(" *.glsl"));
if (video_shader_is_supported(RARCH_SHADER_SLANG))
if (BIT32_GET(flags.flags, GFX_CTX_FLAGS_SHADERS_SLANG))
filter.append(QLatin1String(" *.slang"));
filter.append(")");