gaming/RetroArch
gaming/RetroArch
1
0
Fork 0
mirror of https://github.com/libretro/RetroArch synced 2024-07-08 12:15:49 +00:00
Code Issues Projects Releases Wiki Activity

proper shader compatibility checks

Browse Source 
- move shader flags from the video drivers to the context drivers
 - rework config_load_shader_preset() from configuration.c into retroarch_load_shader_preset() in retroarch.c with proper compatibility check
 - implicitly call retroarch_load_shader_preset() in retroarch_get_shader_preset() once per core/content life cycle
 - use video_shader_is_supported() instead of video_driver_test_all_flags() where appropriate
 - remove GFX_CTX_FLAGS_NONE because it is meaningless
This commit is contained in:
LazyBumHorse 2019-06-17 14:10:55 +02:00
parent 692dc9f6a9
commit c20c67bd3a
40 changed files with 308 additions and 263 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

5
command.c
View File

@ -1302,9 +1302,8 @@ static bool command_event_init_core(enum rarch_core_type *data)
rarch_ctl(RARCH_CTL_UNSET_OVERRIDES_ACTIVE, NULL);
}
/* Auto-shaders: apply shader preset files */
if(settings->bools.auto_shaders_enable)
config_load_shader_preset();
/* Load auto-shaders on the next occasion */
retroarch_shader_presets_set_need_reload();
/* reset video format to libretro's default */
video_driver_set_pixel_format(RETRO_PIXEL_FORMAT_0RGB1555);

125
configuration.c
View File

@ -3520,119 +3520,6 @@ success:
return true;
}
static bool config_load_shader_preset_internal(
const char *shader_directory,
const char *core_name,
const char *special_name)
{
unsigned idx;
size_t path_size = PATH_MAX_LENGTH * sizeof(char);
char *shader_path = (char*)malloc(path_size);
shader_path[0] = '\0';
for (idx = FILE_PATH_CGP_EXTENSION; idx <= FILE_PATH_SLANGP_EXTENSION; idx++)
{
/* Concatenate strings into full paths */
fill_pathname_join_special_ext(shader_path,
shader_directory, core_name,
special_name,
file_path_str((enum file_path_enum)(idx)),
path_size);
if (!config_file_exists(shader_path))
continue;
/* Shader preset exists, load it. */
RARCH_LOG("[Shaders]: Specific shader preset found at %s.\n",
shader_path);
retroarch_set_shader_preset(shader_path);
free(shader_path);
return true;
}
free(shader_path);
return false;
}
/**
* config_load_shader_preset:
*
* Tries to append game-specific and core-specific shader presets.
*
* This function only has an effect if a game-specific or core-specific
* configuration file exists at respective locations.
*
* core-specific: $SHADER_DIR/presets/$CORE_NAME/$CORE_NAME.cfg
* game-specific: $SHADER_DIR/presets/$CORE_NAME/$GAME_NAME.cfg
*
* Returns: false if there was an error or no action was performed.
*/
bool config_load_shader_preset(void)
{
size_t path_size = PATH_MAX_LENGTH * sizeof(char);
settings_t *settings = config_get_ptr();
rarch_system_info_t *system = runloop_get_system_info();
const char *core_name = system
? system->info.library_name : NULL;
const char *rarch_path_basename = path_get(RARCH_PATH_BASENAME);
const char *game_name = path_basename(rarch_path_basename);
const char *video_shader_directory = settings->paths.directory_video_shader;
char *shader_directory = NULL;
if ( string_is_empty(core_name)
|| string_is_empty(game_name)
|| string_is_empty(video_shader_directory)
)
return false;
shader_directory = (char*)
malloc(PATH_MAX_LENGTH * sizeof(char));
shader_directory[0] = '\0';
fill_pathname_join (shader_directory,
video_shader_directory,
"presets", path_size);
RARCH_LOG("[Shaders]: preset directory: %s\n", shader_directory);
if (config_load_shader_preset_internal(shader_directory, core_name,
game_name))
{
RARCH_LOG("[Shaders]: game-specific shader preset found.\n");
goto success;
}
{
char content_dir_name[PATH_MAX_LENGTH];
if (!string_is_empty(rarch_path_basename))
fill_pathname_parent_dir_name(content_dir_name,
rarch_path_basename, sizeof(content_dir_name));
if (config_load_shader_preset_internal(shader_directory, core_name,
content_dir_name))
{
RARCH_LOG("[Shaders]: content dir-specific shader preset found.\n");
goto success;
}
}
if (config_load_shader_preset_internal(shader_directory, core_name,
core_name))
{
RARCH_LOG("[Shaders]: core-specific shader preset found.\n");
goto success;
}
free(shader_directory);
return false;
success:
free(shader_directory);
return true;
}
static void parse_config_file(void)
{
const char *config_path = path_get(RARCH_PATH_CONFIG);
@ -4056,12 +3943,12 @@ bool config_save_overrides(int override_type)
if (string_is_empty(core_name) || string_is_empty(game_name))
return false;
settings = (settings_t*)calloc(1, sizeof(settings_t));
config_directory = (char*)malloc(PATH_MAX_LENGTH * sizeof(char));
override_directory = (char*)malloc(PATH_MAX_LENGTH * sizeof(char));
core_path = (char*)malloc(PATH_MAX_LENGTH * sizeof(char));
game_path = (char*)malloc(PATH_MAX_LENGTH * sizeof(char));
content_path = (char*)malloc(PATH_MAX_LENGTH * sizeof(char));
settings = (settings_t*)calloc(1, sizeof(settings_t));
config_directory = (char*)malloc(PATH_MAX_LENGTH);
override_directory = (char*)malloc(PATH_MAX_LENGTH);
core_path = (char*)malloc(PATH_MAX_LENGTH);
game_path = (char*)malloc(PATH_MAX_LENGTH);
content_path = (char*)malloc(PATH_MAX_LENGTH);
config_directory[0] = override_directory[0] = core_path[0] = game_path[0] = '\0';

10
configuration.h
View File

@ -780,16 +780,6 @@ bool config_unload_override(void);
*/
bool config_load_remap(void);
/**
* config_load_shader_preset:
*
* Tries to append game-specific and core-specific shader presets.
*
* Returns: false if there was an error or no action was performed.
*
*/
bool config_load_shader_preset(void);
/**
* config_save_autoconf_profile:
* @path : Path that shall be written to.

13
gfx/drivers/d3d10.c
View File

@ -948,9 +948,11 @@ d3d10_gfx_init(const video_info_t* video,
font_driver_init_osd(d3d10, false, video->is_threaded, FONT_DRIVER_RENDER_D3D10_API);
const char *shader_preset = retroarch_get_shader_preset();
enum rarch_shader_type type = video_shader_parse_type(shader_preset);
d3d10_gfx_set_shader(d3d10, type, shader_preset);
{
const char *shader_preset = retroarch_get_shader_preset();
enum rarch_shader_type type = video_shader_parse_type(shader_preset);
d3d10_gfx_set_shader(d3d10, type, shader_preset);
}
#if 0
if (video_driver_get_hw_context()->context_type == RETRO_HW_CONTEXT_DIRECT3D &&
@ -1667,12 +1669,9 @@ d3d10_get_hw_render_interface(void* data, const struct retro_hw_render_interface
static uint32_t d3d10_get_flags(void *data)
{
uint32_t flags = 0;
uint32_t flags = 0;
BIT32_SET(flags, GFX_CTX_FLAGS_MENU_FRAME_FILTERING);
#if defined(HAVE_SLANG) && defined(HAVE_SPIRV_CROSS)
BIT32_SET(flags, GFX_CTX_FLAGS_SHADERS_SLANG);
#endif
return flags;
}

13
gfx/drivers/d3d11.c
View File

@ -1024,9 +1024,11 @@ d3d11_gfx_init(const video_info_t* video, const input_driver_t** input, void** i
font_driver_init_osd(d3d11, false, video->is_threaded, FONT_DRIVER_RENDER_D3D11_API);
const char *shader_preset = retroarch_get_shader_preset();
enum rarch_shader_type type = video_shader_parse_type(shader_preset);
d3d11_gfx_set_shader(d3d11, type, shader_preset);
{
const char *shader_preset = retroarch_get_shader_preset();
enum rarch_shader_type type = video_shader_parse_type(shader_preset);
d3d11_gfx_set_shader(d3d11, type, shader_preset);
}
if (video_driver_get_hw_context()->context_type == RETRO_HW_CONTEXT_DIRECT3D &&
video_driver_get_hw_context()->version_major == 11)
@ -1735,12 +1737,9 @@ d3d11_get_hw_render_interface(void* data, const struct retro_hw_render_interface
static uint32_t d3d11_get_flags(void *data)
{
uint32_t flags = 0;
uint32_t flags = 0;
BIT32_SET(flags, GFX_CTX_FLAGS_MENU_FRAME_FILTERING);
#if defined(HAVE_SLANG) && defined(HAVE_SPIRV_CROSS)
BIT32_SET(flags, GFX_CTX_FLAGS_SHADERS_SLANG);
#endif
return flags;
}

13
gfx/drivers/d3d12.c
View File

@ -996,9 +996,11 @@ d3d12_gfx_init(const video_info_t* video, const input_driver_t** input, void** i
font_driver_init_osd(d3d12, false, video->is_threaded, FONT_DRIVER_RENDER_D3D12_API);
const char *shader_preset = retroarch_get_shader_preset();
enum rarch_shader_type type = video_shader_parse_type(shader_preset);
d3d12_gfx_set_shader(d3d12, type, shader_preset);
{
const char *shader_preset = retroarch_get_shader_preset();
enum rarch_shader_type type = video_shader_parse_type(shader_preset);
d3d12_gfx_set_shader(d3d12, type, shader_preset);
}
return d3d12;
@ -1781,12 +1783,9 @@ static void d3d12_gfx_unload_texture(void* data, uintptr_t handle)
static uint32_t d3d12_get_flags(void *data)
{
uint32_t flags = 0;
uint32_t flags = 0;
BIT32_SET(flags, GFX_CTX_FLAGS_MENU_FRAME_FILTERING);
#if defined(HAVE_SLANG) && defined(HAVE_SPIRV_CROSS)
BIT32_SET(flags, GFX_CTX_FLAGS_SHADERS_SLANG);
#endif
return flags;
}

11
gfx/drivers/gl.c
View File

@ -2016,9 +2016,6 @@ static enum rarch_shader_type gl2_get_fallback_shader_type(enum rarch_shader_typ
{
#if defined(HAVE_GLSL) || defined(HAVE_CG)
unsigned i;
gfx_ctx_flags_t flags;
flags.flags = 0;
video_context_driver_get_flags(&flags);
if (type != RARCH_SHADER_CG && type != RARCH_SHADER_GLSL)
{
@ -2034,16 +2031,16 @@ static enum rarch_shader_type gl2_get_fallback_shader_type(enum rarch_shader_typ
{
case RARCH_SHADER_CG:
#ifdef HAVE_CG
if (BIT32_GET(flags.flags, GFX_CTX_FLAGS_SHADERS_CG))
return RARCH_SHADER_CG;
if (video_shader_is_supported(type))
return type;
#endif
type = RARCH_SHADER_GLSL;
break;
case RARCH_SHADER_GLSL:
#ifdef HAVE_GLSL
if (BIT32_GET(flags.flags, GFX_CTX_FLAGS_SHADERS_GLSL))
return RARCH_SHADER_GLSL;
if (video_shader_is_supported(type))
return type;
#endif
type = RARCH_SHADER_CG;
break;

1
gfx/drivers/gl_core.c
View File

@ -1752,7 +1752,6 @@ static uint32_t gl_core_get_flags(void *data)
BIT32_SET(flags, GFX_CTX_FLAGS_HARD_SYNC);
BIT32_SET(flags, GFX_CTX_FLAGS_BLACK_FRAME_INSERTION);
BIT32_SET(flags, GFX_CTX_FLAGS_MENU_FRAME_FILTERING);
BIT32_SET(flags, GFX_CTX_FLAGS_SHADERS_SLANG);
BIT32_SET(flags, GFX_CTX_FLAGS_SCREENSHOTS_SUPPORTED);
return flags;

1
gfx/drivers/gx2_gfx.c
View File

@ -1716,7 +1716,6 @@ static uint32_t wiiu_gfx_get_flags(void *data)
{
uint32_t flags = 0;
BIT32_SET(flags, GFX_CTX_FLAGS_SHADERS_SLANG);
BIT32_SET(flags, GFX_CTX_FLAGS_SCREENSHOTS_SUPPORTED);
return flags;

3
gfx/drivers/metal.m
View File

@ -315,9 +315,6 @@ static uint32_t metal_get_flags(void *data)
BIT32_SET(flags, GFX_CTX_FLAGS_CUSTOMIZABLE_SWAPCHAIN_IMAGES);
BIT32_SET(flags, GFX_CTX_FLAGS_BLACK_FRAME_INSERTION);
BIT32_SET(flags, GFX_CTX_FLAGS_MENU_FRAME_FILTERING);
#if defined(HAVE_SLANG) && defined(HAVE_SPIRV_CROSS)
BIT32_SET(flags, GFX_CTX_FLAGS_SHADERS_SLANG);
#endif
BIT32_SET(flags, GFX_CTX_FLAGS_SCREENSHOTS_SUPPORTED);
return flags;

3
gfx/drivers/vulkan.c
View File

@ -2396,12 +2396,11 @@ static float vulkan_get_refresh_rate(void *data)
static uint32_t vulkan_get_flags(void *data)
{
uint32_t flags = 0;
uint32_t flags = 0;
BIT32_SET(flags, GFX_CTX_FLAGS_CUSTOMIZABLE_SWAPCHAIN_IMAGES);
BIT32_SET(flags, GFX_CTX_FLAGS_BLACK_FRAME_INSERTION);
BIT32_SET(flags, GFX_CTX_FLAGS_MENU_FRAME_FILTERING);
BIT32_SET(flags, GFX_CTX_FLAGS_SHADERS_SLANG);
BIT32_SET(flags, GFX_CTX_FLAGS_SCREENSHOTS_SUPPORTED);
return flags;

3
gfx/drivers_context/android_ctx.c
View File

@ -588,7 +588,6 @@ static void *android_gfx_ctx_get_context_data(void *data)
static uint32_t android_gfx_ctx_get_flags(void *data)
{
uint32_t flags = 0;
BIT32_SET(flags, GFX_CTX_FLAGS_NONE);
switch (android_api)
{
@ -599,7 +598,7 @@ static uint32_t android_gfx_ctx_get_flags(void *data)
#endif
break;
case GFX_CTX_VULKAN_API:
#ifdef HAVE_SLANG
#if defined(HAVE_SLANG) && defined(HAVE_SPIRV_CROSS)
BIT32_SET(flags, GFX_CTX_FLAGS_SHADERS_SLANG);
#endif
break;

13
gfx/drivers_context/cgl_ctx.c
View File

@ -326,7 +326,18 @@ error:
static uint32_t gfx_ctx_cgl_get_flags(void *data)
{
uint32_t flags = 0;
BIT32_SET(flags, GFX_CTX_FLAGS_SHADERS_GLSL);
if (string_is_equal(video_driver_get_ident(), "glcore"))
{
#if defined(HAVE_SLANG) && defined(HAVE_SPIRV_CROSS)
BIT32_SET(flags, GFX_CTX_FLAGS_SHADERS_SLANG);
#endif
}
else
{
BIT32_SET(flags, GFX_CTX_FLAGS_SHADERS_GLSL);
}
return flags;
}

12
gfx/drivers_context/cocoa_gl_ctx.m
View File

@ -108,8 +108,6 @@ static uint32_t cocoagl_gfx_ctx_get_flags(void *data)
uint32_t flags = 0;
cocoa_ctx_data_t *cocoa_ctx = (cocoa_ctx_data_t*)data;
BIT32_SET(flags, GFX_CTX_FLAGS_NONE);
if (cocoa_ctx->core_hw_context_enable)
BIT32_SET(flags, GFX_CTX_FLAGS_GL_CORE_CONTEXT);
@ -122,7 +120,12 @@ static uint32_t cocoagl_gfx_ctx_get_flags(void *data)
break;
case GFX_CTX_OPENGL_API:
if (string_is_equal(video_driver_get_ident(), "gl1")) { }
else if (string_is_equal(video_driver_get_ident(), "glcore")) { }
else if (string_is_equal(video_driver_get_ident(), "glcore"))
{
#if defined(HAVE_SLANG) && defined(HAVE_SPIRV_CROSS)
BIT32_SET(flags, GFX_CTX_FLAGS_SHADERS_SLANG);
#endif
}
else
{
#ifdef HAVE_GLSL
@ -131,6 +134,9 @@ static uint32_t cocoagl_gfx_ctx_get_flags(void *data)
}
break;
case GFX_CTX_VULKAN_API:
#if defined(HAVE_SLANG) && defined(HAVE_SPIRV_CROSS)
BIT32_SET(flags, GFX_CTX_FLAGS_SHADERS_SLANG);
#endif
break;
default:
break;

2
gfx/drivers_context/drm_ctx.c
View File

@ -911,7 +911,7 @@ static uint32_t gfx_ctx_drm_get_flags(void *data)
if (string_is_equal(video_driver_get_ident(), "glcore"))
{
#ifdef HAVE_SLANG
#if defined(HAVE_SLANG) && defined(HAVE_SPIRV_CROSS)
BIT32_SET(flags, GFX_CTX_FLAGS_SHADERS_SLANG);
#endif
}

2
gfx/drivers_context/gdi_ctx.c
View File

@ -341,7 +341,7 @@ static void gfx_ctx_gdi_set_flags(void *data, uint32_t flags)
static uint32_t gfx_ctx_gdi_get_flags(void *data)
{
uint32_t flags = 0;
BIT32_SET(flags, GFX_CTX_FLAGS_NONE);
return flags;
}

1
gfx/drivers_context/gfx_null_ctx.c
View File

@ -123,7 +123,6 @@ static void *gfx_ctx_null_init(video_frame_info_t *video_info, void *video_drive
static uint32_t gfx_ctx_null_get_flags(void *data)
{
uint32_t flags = 0;
BIT32_SET(flags, GFX_CTX_FLAGS_NONE);
return flags;
}

5
gfx/drivers_context/khr_display_ctx.c
View File

@ -257,10 +257,11 @@ static gfx_ctx_proc_t gfx_ctx_khr_display_get_proc_address(const char *symbol)
static uint32_t gfx_ctx_khr_display_get_flags(void *data)
{
uint32_t flags = 0;
BIT32_SET(flags, GFX_CTX_FLAGS_NONE);
#ifdef HAVE_SLANG
#if defined(HAVE_SLANG) && defined(HAVE_SPIRV_CROSS)
BIT32_SET(flags, GFX_CTX_FLAGS_SHADERS_SLANG);
#endif
return flags;
}

2
gfx/drivers_context/mali_fbdev_ctx.c
View File

@ -287,7 +287,7 @@ static void gfx_ctx_mali_fbdev_bind_hw_render(void *data, bool enable)
static uint32_t gfx_ctx_mali_fbdev_get_flags(void *data)
{
uint32_t flags = 0;
BIT32_SET(flags, GFX_CTX_FLAGS_NONE);
BIT32_SET(flags, GFX_CTX_FLAGS_SHADERS_GLSL);
return flags;

3
gfx/drivers_context/opendingux_fbdev_ctx.c
View File

@ -254,8 +254,9 @@ static void gfx_ctx_opendingux_bind_hw_render(void *data, bool enable)
static uint32_t gfx_ctx_opendingux_get_flags(void *data)
{
uint32_t flags = 0;
BIT32_SET(flags, GFX_CTX_FLAGS_NONE);
BIT32_SET(flags, GFX_CTX_FLAGS_SHADERS_GLSL);
return flags;
}

17
gfx/drivers_context/orbis_ctx.c
View File

@ -259,11 +259,20 @@ static void orbis_ctx_bind_hw_render(void *data, bool enable)
static uint32_t orbis_ctx_get_flags(void *data)
{
uint32_t flags = 0;
BIT32_SET(flags, GFX_CTX_FLAGS_NONE);
BIT32_SET(flags, GFX_CTX_FLAGS_SHADERS_GLSL);
uint32_t flags = 0;
return flags;
if (string_is_equal(video_driver_get_ident(), "glcore"))
{
#if defined(HAVE_SLANG) && defined(HAVE_SPIRV_CROSS)
BIT32_SET(flags, GFX_CTX_FLAGS_SHADERS_SLANG);
#endif
}
else
{
BIT32_SET(flags, GFX_CTX_FLAGS_SHADERS_GLSL);
}
return flags;
}
static void orbis_ctx_set_flags(void *data, uint32_t flags)

3
gfx/drivers_context/osmesa_ctx.c
View File

@ -379,8 +379,9 @@ static void osmesa_ctx_show_mouse(void *data, bool state)
static uint32_t osmesa_ctx_get_flags(void *data)
{
uint32_t flags = 0;
BIT32_SET(flags, GFX_CTX_FLAGS_NONE);
BIT32_SET(flags, GFX_CTX_FLAGS_SHADERS_GLSL);
return flags;
}

3
gfx/drivers_context/ps3_ctx.c
View File

@ -405,10 +405,11 @@ static void gfx_ctx_ps3_get_video_output_next(void *data)
static uint32_t gfx_ctx_ps3_get_flags(void *data)
{
uint32_t flags = 0;
BIT32_SET(flags, GFX_CTX_FLAGS_NONE);
#ifdef HAVE_CG
BIT32_SET(flags, GFX_CTX_FLAGS_SHADERS_CG);
#endif
return flags;
}

3
gfx/drivers_context/qnx_ctx.c
View File

@ -452,8 +452,9 @@ static gfx_ctx_proc_t gfx_ctx_qnx_get_proc_address(const char *symbol)
static uint32_t gfx_ctx_qnx_get_flags(void *data)
{
uint32_t flags = 0;
BIT32_SET(flags, GFX_CTX_FLAGS_NONE);
BIT32_SET(flags, GFX_CTX_FLAGS_SHADERS_GLSL);
return flags;
}

2
gfx/drivers_context/sdl_gl_ctx.c
View File

@ -405,7 +405,7 @@ static void sdl_ctx_show_mouse(void *data, bool state)
static uint32_t sdl_ctx_get_flags(void *data)
{
uint32_t flags = 0;
BIT32_SET(flags, GFX_CTX_FLAGS_NONE);
return flags;
}

2
gfx/drivers_context/sixel_ctx.c
View File

@ -181,7 +181,7 @@ static void gfx_ctx_sixel_set_flags(void *data, uint32_t flags)
static uint32_t gfx_ctx_sixel_get_flags(void *data)
{
uint32_t flags = 0;
BIT32_SET(flags, GFX_CTX_FLAGS_NONE);
return flags;
}

15
gfx/drivers_context/switch_ctx.c
View File

@ -267,10 +267,19 @@ static void switch_ctx_bind_hw_render(void *data, bool enable)
static uint32_t switch_ctx_get_flags(void *data)
{
uint32_t flags = 0;
BIT32_SET(flags, GFX_CTX_FLAGS_NONE);
#ifdef HAVE_GLSL
BIT32_SET(flags, GFX_CTX_FLAGS_SHADERS_GLSL);
if (string_is_equal(video_driver_get_ident(), "glcore"))
{
#if defined(HAVE_SLANG) && defined(HAVE_SPIRV_CROSS)
BIT32_SET(flags, GFX_CTX_FLAGS_SHADERS_SLANG);
#endif
}
else
{
#ifdef HAVE_GLSL
BIT32_SET(flags, GFX_CTX_FLAGS_SHADERS_GLSL);
#endif
}
return flags;
}

3
gfx/drivers_context/vivante_fbdev_ctx.c
View File

@ -261,8 +261,9 @@ static void gfx_ctx_vivante_bind_hw_render(void *data, bool enable)
static uint32_t gfx_ctx_vivante_get_flags(void *data)
{
uint32_t flags = 0;
BIT32_SET(flags, GFX_CTX_FLAGS_NONE);
BIT32_SET(flags, GFX_CTX_FLAGS_SHADERS_GLSL);
return flags;
}

8
gfx/drivers_context/wayland_ctx.c
View File

@ -1965,11 +1965,7 @@ static uint32_t gfx_ctx_wl_get_flags(void *data)
gfx_ctx_wayland_data_t *wl = (gfx_ctx_wayland_data_t*)data;
if (wl->core_hw_context_enable)
{
BIT32_SET(flags, GFX_CTX_FLAGS_GL_CORE_CONTEXT);
}
else
BIT32_SET(flags, GFX_CTX_FLAGS_NONE);
switch (wl_api)
{
@ -1977,7 +1973,7 @@ static uint32_t gfx_ctx_wl_get_flags(void *data)
case GFX_CTX_OPENGL_ES_API:
if (string_is_equal(video_driver_get_ident(), "glcore"))
{
#ifdef HAVE_SLANG
#if defined(HAVE_SLANG) && defined(HAVE_SPIRV_CROSS)
BIT32_SET(flags, GFX_CTX_FLAGS_SHADERS_SLANG);
#endif
}
@ -1989,7 +1985,7 @@ static uint32_t gfx_ctx_wl_get_flags(void *data)
}
break;
case GFX_CTX_VULKAN_API:
#ifdef HAVE_SLANG
#if defined(HAVE_SLANG) && defined(HAVE_SPIRV_CROSS)
BIT32_SET(flags, GFX_CTX_FLAGS_SHADERS_SLANG);
#endif
break;

14
gfx/drivers_context/wgl_ctx.c
View File

@ -798,28 +798,22 @@ static void *gfx_ctx_wgl_get_context_data(void *data)
static uint32_t gfx_ctx_wgl_get_flags(void *data)
{
uint32_t flags = 0;
BIT32_SET(flags, GFX_CTX_FLAGS_NONE);
uint32_t flags = 0;
switch (win32_api)
{
case GFX_CTX_OPENGL_API:
if (wgl_adaptive_vsync)
{
BIT32_SET(flags, GFX_CTX_FLAGS_ADAPTIVE_VSYNC);
}
if (win32_core_hw_context_enable)
{
BIT32_SET(flags, GFX_CTX_FLAGS_GL_CORE_CONTEXT);
}
if (string_is_equal(video_driver_get_ident(), "gl1")) { }
else if (string_is_equal(video_driver_get_ident(), "glcore"))
{
#ifdef HAVE_SLANG
BIT32_SET(flags, GFX_CTX_FLAGS_SHADERS_SLANG);
#if defined(HAVE_SLANG) && defined(HAVE_SPIRV_CROSS)
BIT32_SET(flags, GFX_CTX_FLAGS_SHADERS_SLANG);
#endif
}
else
@ -835,7 +829,7 @@ static uint32_t gfx_ctx_wgl_get_flags(void *data)
break;
case GFX_CTX_VULKAN_API:
#ifdef HAVE_SLANG
#if defined(HAVE_SLANG) && defined(HAVE_SPIRV_CROSS)
BIT32_SET(flags, GFX_CTX_FLAGS_SHADERS_SLANG);
#endif
break;

14
gfx/drivers_context/x_ctx.c
View File

@ -1150,29 +1150,23 @@ static uint32_t gfx_ctx_x_get_flags(void *data)
uint32_t flags = 0;
gfx_ctx_x_data_t *x = (gfx_ctx_x_data_t*)data;
BIT32_SET(flags, GFX_CTX_FLAGS_NONE);
switch (x_api)
{
case GFX_CTX_OPENGL_API:
case GFX_CTX_OPENGL_ES_API:
if (x_adaptive_vsync)
{
BIT32_SET(flags, GFX_CTX_FLAGS_ADAPTIVE_VSYNC);
}
if (x->core_hw_context_enable || x->g_core_es)
{
BIT32_SET(flags, GFX_CTX_FLAGS_GL_CORE_CONTEXT);
}
if (x_enable_msaa)
{
BIT32_SET(flags, GFX_CTX_FLAGS_MULTISAMPLING);
}
if (string_is_equal(video_driver_get_ident(), "gl1")) { }
else if (string_is_equal(video_driver_get_ident(), "glcore"))
{
#ifdef HAVE_SLANG
#if defined(HAVE_SLANG) && defined(HAVE_SPIRV_CROSS)
BIT32_SET(flags, GFX_CTX_FLAGS_SHADERS_SLANG);
#endif
}
@ -1188,7 +1182,7 @@ static uint32_t gfx_ctx_x_get_flags(void *data)
}
break;
case GFX_CTX_VULKAN_API:
#ifdef HAVE_SLANG
#if defined(HAVE_SLANG) && defined(HAVE_SPIRV_CROSS)
BIT32_SET(flags, GFX_CTX_FLAGS_SHADERS_SLANG);
#endif
break;

14
gfx/drivers_context/xegl_ctx.c
View File

@ -603,8 +603,18 @@ static gfx_ctx_proc_t gfx_ctx_xegl_get_proc_address(const char *symbol)
static uint32_t gfx_ctx_xegl_get_flags(void *data)
{
uint32_t flags = 0;
BIT32_SET(flags, GFX_CTX_FLAGS_NONE);
BIT32_SET(flags, GFX_CTX_FLAGS_SHADERS_GLSL);
if (string_is_equal(video_driver_get_ident(), "glcore"))
{
#if defined(HAVE_SLANG) && defined(HAVE_SPIRV_CROSS)
BIT32_SET(flags, GFX_CTX_FLAGS_SHADERS_SLANG);
#endif
}
else
{
BIT32_SET(flags, GFX_CTX_FLAGS_SHADERS_GLSL);
}
return flags;
}

39
gfx/video_shader_parse.c
View File

@ -36,6 +36,7 @@
#include "../verbosity.h"
#include "../frontend/frontend_driver.h"
#include "../command.h"
#include "../file_path_special.h"
#include "video_shader_parse.h"
#if defined(HAVE_SLANG) && defined(HAVE_SPIRV_CROSS)
@ -1150,30 +1151,56 @@ const char *video_shader_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.
**/
bool video_shader_is_supported(enum rarch_shader_type type)
{
enum display_flags flag = GFX_CTX_FLAGS_NONE;
gfx_ctx_flags_t flags;
enum display_flags testflag;
switch (type)
{
case RARCH_SHADER_SLANG:
flag = GFX_CTX_FLAGS_SHADERS_SLANG;
testflag = GFX_CTX_FLAGS_SHADERS_SLANG;
break;
case RARCH_SHADER_GLSL:
flag = GFX_CTX_FLAGS_SHADERS_GLSL;
testflag = GFX_CTX_FLAGS_SHADERS_GLSL;
break;
case RARCH_SHADER_CG:
flag = GFX_CTX_FLAGS_SHADERS_CG;
testflag = GFX_CTX_FLAGS_SHADERS_CG;
break;
case RARCH_SHADER_HLSL:
flag = GFX_CTX_FLAGS_SHADERS_HLSL;
testflag = GFX_CTX_FLAGS_SHADERS_HLSL;
break;
case RARCH_SHADER_NONE:
default:
return false;
}
return video_driver_test_all_flags(flag);
video_context_driver_get_flags(&flags);
return BIT32_GET(flags.flags, testflag);
}
const char *video_shader_get_preset_extension(enum rarch_shader_type type)
{
switch (type)
{
case RARCH_SHADER_GLSL:
return file_path_str(FILE_PATH_GLSLP_EXTENSION);
case RARCH_SHADER_SLANG:
return file_path_str(FILE_PATH_SLANGP_EXTENSION);
case RARCH_SHADER_HLSL:
case RARCH_SHADER_CG:
return file_path_str(FILE_PATH_CGP_EXTENSION);
default:
break;
}
return NULL;
}
bool video_shader_any_supported(void)

2
gfx/video_shader_parse.h
View File

@ -250,6 +250,8 @@ bool video_shader_check_for_changes(void);
const char *video_shader_to_str(enum rarch_shader_type type);
const char *video_shader_get_preset_extension(enum rarch_shader_type type);
RETRO_END_DECLS
#endif

6
list_special.c
View File

@ -98,19 +98,19 @@ 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))
if (video_shader_is_supported(RARCH_SHADER_CG))
{
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))
if (video_shader_is_supported(RARCH_SHADER_GLSL))
{
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))
if (video_shader_is_supported(RARCH_SHADER_SLANG))
{
string_list_append(str_list, "slangp", attr);
string_list_append(str_list, "slang", attr);

12
menu/menu_displaylist.c
View File

@ -6804,7 +6804,7 @@ 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))
if (video_shader_is_supported(RARCH_SHADER_CG))
{
if (menu_entries_append_enum(info->list,
msg_hash_to_str(MENU_ENUM_LABEL_VALUE_UPDATE_CG_SHADERS),
@ -6814,7 +6814,7 @@ bool menu_displaylist_ctl(enum menu_displaylist_ctl_state type,
count++;
}
if (video_driver_test_all_flags(GFX_CTX_FLAGS_SHADERS_GLSL))
if (video_shader_is_supported(RARCH_SHADER_GLSL))
{
if (menu_entries_append_enum(info->list,
msg_hash_to_str(MENU_ENUM_LABEL_VALUE_UPDATE_GLSL_SHADERS),
@ -6824,7 +6824,7 @@ bool menu_displaylist_ctl(enum menu_displaylist_ctl_state type,
count++;
}
if (video_driver_test_all_flags(GFX_CTX_FLAGS_SHADERS_SLANG))
if (video_shader_is_supported(RARCH_SHADER_SLANG))
{
if (menu_entries_append_enum(info->list,
msg_hash_to_str(MENU_ENUM_LABEL_VALUE_UPDATE_SLANG_SHADERS),
@ -7464,7 +7464,7 @@ 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))
if (video_shader_is_supported(RARCH_SHADER_CG))
{
if (type == DISPLAYLIST_SHADER_PRESET)
string_list_append(str_list, "cgp", attr);
@ -7472,7 +7472,7 @@ bool menu_displaylist_ctl(enum menu_displaylist_ctl_state type,
string_list_append(str_list, "cg", attr);
}
if (video_driver_test_all_flags(GFX_CTX_FLAGS_SHADERS_GLSL))
if (video_shader_is_supported(RARCH_SHADER_GLSL))
{
if (type == DISPLAYLIST_SHADER_PRESET)
string_list_append(str_list, "glslp", attr);
@ -7480,7 +7480,7 @@ bool menu_displaylist_ctl(enum menu_displaylist_ctl_state type,
string_list_append(str_list, "glsl", attr);
}
if (video_driver_test_all_flags(GFX_CTX_FLAGS_SHADERS_SLANG))
if (video_shader_is_supported(RARCH_SHADER_SLANG))
{
if (type == DISPLAYLIST_SHADER_PRESET)
string_list_append(str_list, "slangp", attr);

20
menu/menu_shader.c
View File

@ -195,22 +195,6 @@ bool menu_shader_manager_set_preset(void *data,
return true;
}
static const char *shader_get_preset_extension(unsigned type)
{
switch (type)
{
case RARCH_SHADER_GLSL:
return file_path_str(FILE_PATH_GLSLP_EXTENSION);
case RARCH_SHADER_SLANG:
return file_path_str(FILE_PATH_SLANGP_EXTENSION);
case RARCH_SHADER_HLSL:
case RARCH_SHADER_CG:
return file_path_str(FILE_PATH_CGP_EXTENSION);
}
return NULL;
}
/**
* menu_shader_manager_save_preset:
* @basename : basename of preset
@ -255,7 +239,7 @@ bool menu_shader_manager_save_preset(
&& !strstr(basename,
file_path_str(FILE_PATH_SLANGP_EXTENSION)))
{
const char *preset_ext = shader_get_preset_extension(type);
const char *preset_ext = video_shader_get_preset_extension(type);
if (!string_is_empty(preset_ext))
strlcat(buffer, preset_ext, sizeof(buffer));
}
@ -271,7 +255,7 @@ bool menu_shader_manager_save_preset(
const char *config_path = path_get(RARCH_PATH_CONFIG);
/* In a multi-config setting, we can't have
* conflicts on menu.cgp/menu.glslp. */
const char *preset_ext = shader_get_preset_extension(type);
const char *preset_ext = video_shader_get_preset_extension(type);
if (!string_is_empty(preset_ext))
{

136
retroarch.c
View File

@ -242,6 +242,7 @@ static enum rarch_core_type current_core_type = CORE_TYPE_PLAI
static enum rarch_core_type explicit_current_core_type = CORE_TYPE_PLAIN;
static char error_string[255] = {0};
static char runtime_shader_preset[255] = {0};
static bool shader_presets_need_reload = true;
#ifdef HAVE_THREAD_STORAGE
static sthread_tls_t rarch_tls;
@ -13760,6 +13761,131 @@ void retroarch_unset_shader_preset(void)
runtime_shader_preset[0] = '\0';
}
static bool retroarch_load_shader_preset_internal(
const char *shader_directory,
const char *core_name,
const char *special_name)
{
unsigned i;
char *shader_path = (char*)malloc(PATH_MAX_LENGTH);
static enum rarch_shader_type types[] =
{
/* Shader preset priority, highest to lowest
* only important for video drivers with multiple shader backends */
RARCH_SHADER_GLSL, RARCH_SHADER_SLANG, RARCH_SHADER_CG, RARCH_SHADER_HLSL
};
for (i = 0; i < ARRAY_SIZE(types); i++)
{
if (!video_shader_is_supported(types[i]))
continue;
/* Concatenate strings into full paths */
fill_pathname_join_special_ext(shader_path,
shader_directory, core_name,
special_name,
video_shader_get_preset_extension(types[i]),
PATH_MAX_LENGTH);
if (!config_file_exists(shader_path))
continue;
/* Shader preset exists, load it. */
RARCH_LOG("[Shaders]: Specific shader preset found at %s.\n",
shader_path);
retroarch_set_shader_preset(shader_path);
free(shader_path);
return true;
}
free(shader_path);
return false;
}
/**
* retroarch_load_shader_preset:
*
* Tries to load a supported core-, game- or folder-specific shader preset
* from its respective location:
*
* core-specific: $SHADER_DIR/presets/$CORE_NAME/$CORE_NAME.$PRESET_EXT
* folder-specific: $SHADER_DIR/presets/$CORE_NAME/$FOLDER_NAME.$PRESET_EXT
* game-specific: $SHADER_DIR/presets/$CORE_NAME/$GAME_NAME.$PRESET_EXT
*
* Note: Uses video_shader_is_supported() which only works after
* context driver initialization.
*
* Returns: false if there was an error or no action was performed.
*/
static bool retroarch_load_shader_preset(void)
{
const settings_t *settings = config_get_ptr();
const rarch_system_info_t *system = runloop_get_system_info();
const char *video_shader_directory = settings->paths.directory_video_shader;
const char *core_name = system ? system->info.library_name : NULL;
const char *rarch_path_basename = path_get(RARCH_PATH_BASENAME);
const char *game_name = path_basename(rarch_path_basename);
char *shader_directory;
if (!settings->bools.auto_shaders_enable)
return false;
if (string_is_empty(video_shader_directory) ||
string_is_empty(core_name) ||
string_is_empty(game_name))
return false;
shader_directory = (char*)malloc(PATH_MAX_LENGTH);
fill_pathname_join(shader_directory,
video_shader_directory,
"presets", PATH_MAX_LENGTH);
RARCH_LOG("[Shaders]: preset directory: %s\n", shader_directory);
if (retroarch_load_shader_preset_internal(shader_directory, core_name,
game_name))
{
RARCH_LOG("[Shaders]: game-specific shader preset found.\n");
goto success;
}
{
char content_dir_name[PATH_MAX_LENGTH];
if (!string_is_empty(rarch_path_basename))
fill_pathname_parent_dir_name(content_dir_name,
rarch_path_basename, sizeof(content_dir_name));
if (retroarch_load_shader_preset_internal(shader_directory, core_name,
content_dir_name))
{
RARCH_LOG("[Shaders]: folder-specific shader preset found.\n");
goto success;
}
}
if (retroarch_load_shader_preset_internal(shader_directory, core_name,
core_name))
{
RARCH_LOG("[Shaders]: core-specific shader preset found.\n");
goto success;
}
free(shader_directory);
return false;
success:
free(shader_directory);
return true;
}
void retroarch_shader_presets_set_need_reload()
{
shader_presets_need_reload = true;
}
/* get the name of the current shader preset */
char* retroarch_get_shader_preset(void)
{
@ -13767,10 +13893,18 @@ char* retroarch_get_shader_preset(void)
if (!settings->bools.video_shader_enable)
return NULL;
if (shader_presets_need_reload)
{
retroarch_load_shader_preset();
shader_presets_need_reload = false;
}
if (!string_is_empty(runtime_shader_preset))
return runtime_shader_preset;
else if (!string_is_empty(settings->paths.path_shader))
if (!string_is_empty(settings->paths.path_shader))
return settings->paths.path_shader;
return NULL;
}

5
retroarch.h
View File

@ -357,6 +357,8 @@ void retroarch_unset_shader_preset(void);
char* retroarch_get_shader_preset(void);
void retroarch_shader_presets_set_need_reload(void);
bool retroarch_is_switching_display_mode(void);
void retroarch_set_switching_display_mode(void);
@ -949,8 +951,7 @@ enum display_metric_types
enum display_flags
{
GFX_CTX_FLAGS_NONE = 0,
GFX_CTX_FLAGS_GL_CORE_CONTEXT,
GFX_CTX_FLAGS_GL_CORE_CONTEXT = 0,
GFX_CTX_FLAGS_MULTISAMPLING,
GFX_CTX_FLAGS_CUSTOMIZABLE_SWAPCHAIN_IMAGES,
GFX_CTX_FLAGS_HARD_SYNC,

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

@ -484,13 +484,13 @@ 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? */
if (video_driver_test_all_flags(GFX_CTX_FLAGS_SHADERS_CG))
if (video_shader_is_supported(RARCH_SHADER_CG))
filter += QLatin1Literal(" *") + file_path_str(FILE_PATH_CGP_EXTENSION);
if (video_driver_test_all_flags(GFX_CTX_FLAGS_SHADERS_GLSL))
if (video_shader_is_supported(RARCH_SHADER_GLSL))
filter += QLatin1Literal(" *") + file_path_str(FILE_PATH_GLSLP_EXTENSION);
if (video_driver_test_all_flags(GFX_CTX_FLAGS_SHADERS_SLANG))
if (video_shader_is_supported(RARCH_SHADER_SLANG))
filter += QLatin1Literal(" *") + file_path_str(FILE_PATH_SLANGP_EXTENSION);
filter += ")";
@ -617,13 +617,13 @@ 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? */
if (video_driver_test_all_flags(GFX_CTX_FLAGS_SHADERS_CG))
if (video_shader_is_supported(RARCH_SHADER_CG))
filter += QLatin1Literal(" *.cg");
if (video_driver_test_all_flags(GFX_CTX_FLAGS_SHADERS_GLSL))
if (video_shader_is_supported(RARCH_SHADER_GLSL))
filter += QLatin1Literal(" *.glsl");
if (video_driver_test_all_flags(GFX_CTX_FLAGS_SHADERS_SLANG))
if (video_shader_is_supported(RARCH_SHADER_SLANG))
filter += QLatin1Literal(" *.slang");
filter += ")";