mirror/RetroArch
1
0
Fork 0
mirror of https://github.com/libretro/RetroArch synced 2025-02-07 12:39:54 +00:00
Code Issues Packages Projects Releases Wiki Activity

Merge pull request #8910 from LazyBumHorse/video_shader_parse_refactor

Browse Source 
(Discussion) about video driver shader compatibility (+ proper fix for #8834)
This commit is contained in:
Twinaphex 2019-06-18 14:35:16 +02:00 committed by GitHub
commit 579ff877e4
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
49 changed files with 769 additions and 816 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

7
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),
@ -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);

182
configuration.c
View File

@ -2608,35 +2608,6 @@ static bool check_menu_driver_compatibility(void)
}
#endif
static bool check_shader_compatibility(enum file_path_enum enum_idx)
{
settings_t *settings = config_get_ptr();
if (string_is_equal(settings->arrays.video_driver, "vulkan") ||
string_is_equal(settings->arrays.video_driver, "metal") ||
string_is_equal(settings->arrays.video_driver, "glcore") ||
string_is_equal(settings->arrays.video_driver, "d3d11") ||
string_is_equal(settings->arrays.video_driver, "d3d12") ||
string_is_equal(settings->arrays.video_driver, "gx2"))
{
if (enum_idx != FILE_PATH_SLANGP_EXTENSION)
return false;
return true;
}
if (string_is_equal(settings->arrays.video_driver, "gl") ||
string_is_equal(settings->arrays.video_driver, "d3d8") ||
string_is_equal(settings->arrays.video_driver, "d3d9")
)
{
if (enum_idx == FILE_PATH_SLANGP_EXTENSION)
return false;
return true;
}
return false;
}
/**
* config_load:
* @path : path to be read from.
@ -3125,26 +3096,6 @@ static bool config_load_file(const char *path, settings_t *settings)
config_read_keybinds_conf(conf);
shader_ext = path_get_extension(settings->paths.path_shader);
if (!string_is_empty(shader_ext))
{
for (i = FILE_PATH_CGP_EXTENSION; i <= FILE_PATH_SLANGP_EXTENSION; i++)
{
enum file_path_enum ext = (enum file_path_enum)(i);
if (!strstr(file_path_str(ext), shader_ext))
continue;
if (check_shader_compatibility(ext))
continue;
RARCH_LOG("Incompatible shader for backend %s, clearing...\n",
settings->arrays.video_driver);
settings->paths.path_shader[0] = '\0';
break;
}
}
#if defined(HAVE_MENU) && defined(HAVE_RGUI)
if (!check_menu_driver_compatibility())
strlcpy(settings->arrays.menu_driver, "rgui", sizeof(settings->arrays.menu_driver));
@ -3569,122 +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++)
{
if (!check_shader_compatibility((enum file_path_enum)(idx)))
continue;
/* 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);
@ -4108,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';
@ -4398,8 +4233,5 @@ bool config_replace(bool config_replace_save_on_exit, char *path)
/* Load core in new config. */
path_clear(RARCH_PATH_CORE);
if (!task_push_start_dummy_core(&content_info))
return false;
return true;
return task_push_start_dummy_core(&content_info);
}

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.

6
gfx/common/metal_common.m
View File

@ -1134,6 +1134,10 @@ typedef struct MTLALIGN(16)
- (BOOL)setShaderFromPath:(NSString *)path
{
/* TODO use stock shader if string_is_empty(path.UTF8String), this is just a safety guard: */
if (string_is_empty(path.UTF8String))
return YES;
[self _freeVideoShader:_shader];
_shader = nil;
@ -1196,7 +1200,7 @@ typedef struct MTLALIGN(16)
return NO;
#ifdef DEBUG
bool save_msl = true;
bool save_msl = true;
#else
bool save_msl = false;
#endif

21
gfx/drivers/d3d10.c
View File

@ -322,8 +322,7 @@ static void d3d10_free_shader_preset(d3d10_video_t* d3d10)
d3d10->resize_render_targets = false;
}
static bool d3d10_gfx_set_shader(void* data,
enum rarch_shader_type type, const char* path)
static bool d3d10_gfx_set_shader(void* data, enum rarch_shader_type type, const char* path)
{
#if defined(HAVE_SLANG) && defined(HAVE_SPIRV_CROSS)
unsigned i;
@ -337,12 +336,12 @@ static bool d3d10_gfx_set_shader(void* data,
D3D10Flush(d3d10->device);
d3d10_free_shader_preset(d3d10);
if (!path)
if (string_is_empty(path))
return true;
if (type != RARCH_SHADER_SLANG)
{
RARCH_WARN("Only .slang or .slangp shaders are supported. Falling back to stock.\n");
RARCH_WARN("[D3D10] Only Slang shaders are supported. Falling back to stock.\n");
return false;
}
@ -423,7 +422,6 @@ static bool d3d10_gfx_set_shader(void* data,
const char* slang_path = d3d10->shader_preset->pass[i].source.path;
const char* vs_src = d3d10->shader_preset->pass[i].source.string.vertex;
const char* ps_src = d3d10->shader_preset->pass[i].source.string.fragment;
int base_len = strlen(slang_path) - STRLEN_CONST(".slang");
strlcpy(vs_path, slang_path, sizeof(vs_path));
strlcpy(ps_path, slang_path, sizeof(ps_path));
@ -950,12 +948,10 @@ d3d10_gfx_init(const video_info_t* video,
font_driver_init_osd(d3d10, false, video->is_threaded, FONT_DRIVER_RENDER_D3D10_API);
if (settings->bools.video_shader_enable)
{
const char* ext = path_get_extension(retroarch_get_shader_preset());
if (ext && !strncmp(ext, "slang", 5))
d3d10_gfx_set_shader(d3d10, RARCH_SHADER_SLANG, retroarch_get_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
@ -1673,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;
}

17
gfx/drivers/d3d11.c
View File

@ -355,12 +355,12 @@ static bool d3d11_gfx_set_shader(void* data, enum rarch_shader_type type, const
D3D11Flush(d3d11->context);
d3d11_free_shader_preset(d3d11);
if (!path)
if (string_is_empty(path))
return true;
if (type != RARCH_SHADER_SLANG)
{
RARCH_WARN("Only .slang or .slangp shaders are supported. Falling back to stock.\n");
RARCH_WARN("[D3D11] Only Slang shaders are supported. Falling back to stock.\n");
return false;
}
@ -1024,12 +1024,10 @@ 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);
if (settings->bools.video_shader_enable)
{
const char* ext = path_get_extension(retroarch_get_shader_preset());
if (ext && !strncmp(ext, "slang", 5))
d3d11_gfx_set_shader(d3d11, RARCH_SHADER_SLANG, retroarch_get_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 &&
@ -1739,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;
}

29
gfx/drivers/d3d12.c
View File

@ -334,23 +334,22 @@ static bool d3d12_gfx_set_shader(void* data, enum rarch_shader_type type, const
{
#if defined(HAVE_SLANG) && defined(HAVE_SPIRV_CROSS)
unsigned i;
d3d12_texture_t* source = NULL;
config_file_t* conf = NULL;
d3d12_texture_t* source = NULL;
d3d12_video_t* d3d12 = (d3d12_video_t*)data;
if (!d3d12)
return false;
d3d12_gfx_sync(d3d12);
d3d12_free_shader_preset(d3d12);
if (!path)
if (string_is_empty(path))
return true;
if (type != RARCH_SHADER_SLANG)
{
RARCH_WARN("Only .slang or .slangp shaders are supported. Falling back to stock.\n");
RARCH_WARN("[D3D12] Only Slang shaders are supported. Falling back to stock.\n");
return false;
}
@ -408,8 +407,8 @@ static bool d3d12_gfx_set_shader(void* data, enum rarch_shader_type type, const
/* clang-format on */
if (!slang_process(
d3d12->shader_preset, i, RARCH_SHADER_HLSL, 50, &semantics_map,
&d3d12->pass[i].semantics))
d3d12->shader_preset, i, RARCH_SHADER_HLSL, 50, &semantics_map,
&d3d12->pass[i].semantics))
goto error;
{
@ -435,7 +434,6 @@ static bool d3d12_gfx_set_shader(void* data, enum rarch_shader_type type, const
const char* slang_path = d3d12->shader_preset->pass[i].source.path;
const char* vs_src = d3d12->shader_preset->pass[i].source.string.vertex;
const char* ps_src = d3d12->shader_preset->pass[i].source.string.fragment;
int base_len = strlen(slang_path) - STRLEN_CONST(".slang");
strlcpy(vs_path, slang_path, sizeof(vs_path));
strlcpy(ps_path, slang_path, sizeof(ps_path));
@ -581,8 +579,8 @@ static bool d3d12_gfx_init_pipelines(d3d12_video_t* d3d12)
desc.InputLayout.NumElements = countof(inputElementDesc);
if (!d3d12_init_pipeline(
d3d12->device, vs_code, ps_code, NULL, &desc,
&d3d12->pipes[VIDEO_SHADER_STOCK_BLEND]))
d3d12->device, vs_code, ps_code, NULL, &desc,
&d3d12->pipes[VIDEO_SHADER_STOCK_BLEND]))
goto error;
Release(vs_code);
@ -998,12 +996,10 @@ 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);
if (settings->bools.video_shader_enable)
{
const char* ext = path_get_extension(retroarch_get_shader_preset());
if (ext && string_is_equal(ext, "slangp"))
d3d12_gfx_set_shader(d3d12, RARCH_SHADER_SLANG, retroarch_get_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;
@ -1787,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;
}

24
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)
{
@ -1808,13 +1807,18 @@ end:
static bool d3d9_set_shader(void *data,
enum rarch_shader_type type, const char *path)
{
d3d9_video_t *d3d = (d3d9_video_t*)data;
char *old_shader = (d3d && !string_is_empty(d3d->shader_path)) ? strdup(d3d->shader_path) : NULL;
d3d9_video_t *d3d = (d3d9_video_t*)data;
if (!d3d)
return false;
if (!string_is_empty(d3d->shader_path))
free(d3d->shader_path);
d3d->shader_path = NULL;
if (string_is_empty(path))
return true;
switch (type)
{
case RARCH_SHADER_CG:
@ -1823,19 +1827,13 @@ static bool d3d9_set_shader(void *data,
d3d->shader_path = strdup(path);
break;
default:
break;
RARCH_WARN("[D3D9]: Only Cg shaders are supported. Falling back to stock.\n");
return false;
}
if (!d3d9_process_shader(d3d) || !d3d9_restore(d3d))
{
RARCH_ERR("[D3D9]: Setting shader failed.\n");
if (!string_is_empty(old_shader))
{
d3d->shader_path = strdup(old_shader);
d3d9_process_shader(d3d);
d3d9_restore(d3d);
}
free(old_shader);
RARCH_ERR("[D3D9]: Failed to set shader.\n");
return false;
}

208
gfx/drivers/gl.c
View File

@ -1998,45 +1998,84 @@ static void gl2_set_viewport_wrapper(void *data, unsigned viewport_width,
}
/* Shaders */
/**
* gl2_get_fallback_shader_type:
* @type : shader type which should be used if possible
*
* Returns a supported fallback shader type in case the given one is not supported.
* For gl2, shader support is completely defined by the context driver shader flags.
*
* gl2_get_fallback_shader_type(RARCH_SHADER_NONE) returns a default shader type.
* if gl2_get_fallback_shader_type(type) != type, type was not supported.
*
* Returns: A supported shader type.
* If RARCH_SHADER_NONE is returned, no shader backend is supported.
**/
static enum rarch_shader_type gl2_get_fallback_shader_type(enum rarch_shader_type type)
{
#if defined(HAVE_GLSL) || defined(HAVE_CG)
unsigned i;
if (type != RARCH_SHADER_CG && type != RARCH_SHADER_GLSL)
{
type = DEFAULT_SHADER_TYPE;
if (type != RARCH_SHADER_CG && type != RARCH_SHADER_GLSL)
type = RARCH_SHADER_GLSL;
}
for (i = 0; i < 2; i++)
{
switch (type)
{
case RARCH_SHADER_CG:
#ifdef HAVE_CG
if (video_shader_is_supported(type))
return type;
#endif
type = RARCH_SHADER_GLSL;
break;
case RARCH_SHADER_GLSL:
#ifdef HAVE_GLSL
if (video_shader_is_supported(type))
return type;
#endif
type = RARCH_SHADER_CG;
break;
default:
return RARCH_SHADER_NONE;
}
}
#endif
return RARCH_SHADER_NONE;
}
static const shader_backend_t *gl_shader_driver_set_backend(
enum rarch_shader_type type)
{
switch (type)
enum rarch_shader_type fallback = gl2_get_fallback_shader_type(type);
if (fallback != type)
RARCH_ERR("[Shader driver]: Shader backend %d not supported, falling back to %d.", type, fallback);
switch (fallback)
{
case RARCH_SHADER_CG:
{
#ifdef HAVE_CG
gfx_ctx_flags_t flags;
flags.flags = 0;
video_context_driver_get_flags(&flags);
if (BIT32_GET(flags.flags, GFX_CTX_FLAGS_GL_CORE_CONTEXT))
{
RARCH_ERR("[Shader driver]: Cg cannot be used with core"
" GL context. Trying to fall back to GLSL...\n");
return gl_shader_driver_set_backend(RARCH_SHADER_GLSL);
}
RARCH_LOG("[Shader driver]: Using Cg shader backend.\n");
return &gl_cg_backend;
#else
break;
case RARCH_SHADER_CG:
RARCH_LOG("[Shader driver]: Using Cg shader backend.\n");
return &gl_cg_backend;
#endif
}
case RARCH_SHADER_GLSL:
#ifdef HAVE_GLSL
case RARCH_SHADER_GLSL:
RARCH_LOG("[Shader driver]: Using GLSL shader backend.\n");
return &gl_glsl_backend;
#else
break;
#endif
case RARCH_SHADER_HLSL:
case RARCH_SHADER_NONE:
default:
break;
RARCH_LOG("[Shader driver]: No supported shader backend.\n");
return NULL;
}
return NULL;
}
static bool gl_shader_driver_init(video_shader_ctx_init_t *init)
@ -2064,7 +2103,7 @@ static bool gl_shader_driver_init(video_shader_ctx_init_t *init)
init->shader->init_menu_shaders(tmp);
}
init->shader_data = tmp;
init->shader_data = tmp;
return true;
}
@ -2074,37 +2113,33 @@ 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();
bool ret = false;
const char *shader_path = retroarch_get_shader_preset();
enum rarch_shader_type parse_type = video_shader_parse_type(shader_path);
enum rarch_shader_type type;
if (shader_path)
type = gl2_get_fallback_shader_type(parse_type);
if (type == RARCH_SHADER_NONE)
{
type = video_shader_parse_type(shader_path,
gl->core_context_in_use
? RARCH_SHADER_GLSL : DEFAULT_SHADER_TYPE);
RARCH_ERR("[GL]: Couldn't find any supported shader backend! Continuing without shaders.\n");
return true;
}
switch (type)
if (type != parse_type)
{
#ifdef HAVE_CG
case RARCH_SHADER_CG:
if (gl->core_context_in_use)
shader_path = NULL;
break;
#endif
if (!string_is_empty(shader_path))
RARCH_WARN("[GL] Shader preset %s is using unsupported shader type %s, falling back to stock %s.\n",
shader_path, video_shader_to_str(parse_type), video_shader_to_str(type));
#ifdef HAVE_GLSL
case RARCH_SHADER_GLSL:
gl_glsl_set_get_proc_address(ctx_driver->get_proc_address);
gl_glsl_set_context_type(gl->core_context_in_use,
hwr->version_major, hwr->version_minor);
break;
#endif
shader_path = NULL;
}
default:
RARCH_ERR("[GL]: Not loading any shader, or couldn't find valid shader backend. Continuing without shaders.\n");
return true;
if (type == RARCH_SHADER_GLSL)
{
gl_glsl_set_get_proc_address(ctx_driver->get_proc_address);
gl_glsl_set_context_type(gl->core_context_in_use,
hwr->version_major, hwr->version_minor);
}
init_data.gl.core_context_enabled = gl->core_context_in_use;
@ -3991,10 +4026,7 @@ static void gl2_update_tex_filter_frame(gl_t *gl)
smooth = settings->bools.video_smooth;
mip_level = 1;
wrap_type = gl->shader->wrap_type(
gl->shader_data, 1);
wrap_type = gl->shader->wrap_type(gl->shader_data, 1);
wrap_mode = gl2_wrap_type_to_enum(wrap_type);
gl->tex_mipmap = gl->shader->mipmap_input(gl->shader_data, mip_level);
gl->video_info.smooth = smooth;
@ -4028,6 +4060,7 @@ static bool gl2_set_shader(void *data,
#if defined(HAVE_GLSL) || defined(HAVE_CG)
unsigned textures;
video_shader_ctx_init_t init_data;
enum rarch_shader_type fallback;
gl_t *gl = (gl_t*)data;
if (!gl)
@ -4035,27 +4068,28 @@ static bool gl2_set_shader(void *data,
gl2_context_bind_hw_render(gl, false);
if (type == RARCH_SHADER_NONE)
return false;
gl->shader->deinit(gl->shader_data);
gl->shader_data = NULL;
switch (type)
if (string_is_empty(path))
{
#ifdef HAVE_GLSL
case RARCH_SHADER_GLSL:
break;
#endif
gl2_context_bind_hw_render(gl, true);
return true;
}
#ifdef HAVE_CG
case RARCH_SHADER_CG:
break;
#endif
fallback = gl2_get_fallback_shader_type(type);
default:
RARCH_ERR("[GL]: Cannot find shader core for path: %s.\n", path);
goto error;
if (fallback == RARCH_SHADER_NONE)
{
RARCH_ERR("[GL]: No supported shader backend found!\n");
goto error;
}
if (type != fallback)
{
RARCH_ERR("[GL]: %s shader not supported, falling back to stock %s\n",
video_shader_to_str(type), video_shader_to_str(fallback));
path = NULL;
}
if (gl->fbo_inited)
@ -4066,7 +4100,7 @@ static bool gl2_set_shader(void *data,
glBindTexture(GL_TEXTURE_2D, gl->texture[gl->tex_index]);
}
init_data.shader_type = type;
init_data.shader_type = fallback;
init_data.shader = NULL;
init_data.data = gl;
init_data.path = path;
@ -4125,12 +4159,12 @@ static bool gl2_set_shader(void *data,
/* Apparently need to set viewport for passes when we aren't using FBOs. */
gl2_set_shader_viewports(gl);
gl2_context_bind_hw_render(gl, true);
#endif
return true;
error:
gl2_context_bind_hw_render(gl, true);
#endif
return false;
}
@ -4138,7 +4172,7 @@ static void gl2_viewport_info(void *data, struct video_viewport *vp)
{
unsigned width, height;
unsigned top_y, top_dist;
gl_t *gl = (gl_t*)data;
gl_t *gl = (gl_t*)data;
video_driver_get_size(&width, &height);
@ -4155,10 +4189,11 @@ static void gl2_viewport_info(void *data, struct video_viewport *vp)
static bool gl2_read_viewport(void *data, uint8_t *buffer, bool is_idle)
{
gl_t *gl = (gl_t*)data;
if (!gl)
return false;
return gl2_renderchain_read_viewport(gl,
buffer, is_idle);
return gl2_renderchain_read_viewport(gl, buffer, is_idle);
}
#if 0
@ -4252,7 +4287,7 @@ static bool gl2_overlay_load(void *data,
|| !gl->overlay_color_coord)
return false;
gl->overlays = num_images;
gl->overlays = num_images;
glGenTextures(num_images, gl->overlay_tex);
for (i = 0; i < num_images; i++)
@ -4280,7 +4315,7 @@ static bool gl2_overlay_load(void *data,
static void gl2_overlay_enable(void *data, bool state)
{
gl_t *gl = (gl_t*)data;
gl_t *gl = (gl_t*)data;
if (!gl)
return;
@ -4301,17 +4336,18 @@ static void gl2_overlay_full_screen(void *data, bool enable)
static void gl2_overlay_set_alpha(void *data, unsigned image, float mod)
{
GLfloat *color = NULL;
gl_t *gl = (gl_t*)data;
GLfloat *color;
gl_t *gl = (gl_t*)data;
if (!gl)
return;
color = (GLfloat*)&gl->overlay_color_coord[image * 16];
color = (GLfloat*)&gl->overlay_color_coord[image * 16];
color[ 0 + 3] = mod;
color[ 4 + 3] = mod;
color[ 8 + 3] = mod;
color[12 + 3] = mod;
color[ 0 + 3] = mod;
color[ 4 + 3] = mod;
color[ 8 + 3] = mod;
color[12 + 3] = mod;
}
static const video_overlay_interface_t gl2_overlay_interface = {
@ -4345,7 +4381,7 @@ static retro_proc_address_t gl2_get_proc_address(void *data, const char *sym)
static void gl2_set_aspect_ratio(void *data, unsigned aspect_ratio_idx)
{
gl_t *gl = (gl_t*)data;
gl_t *gl = (gl_t*)data;
switch (aspect_ratio_idx)
{

26
gfx/drivers/gl_core.c
View File

@ -779,11 +779,10 @@ 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);
enum rarch_shader_type type = video_shader_parse_type(shader_path, RARCH_SHADER_NONE);
if (type == RARCH_SHADER_NONE)
if (string_is_empty(shader_path))
{
RARCH_LOG("[GLCore]: Loading stock shader.\n");
return gl_core_init_default_filter_chain(gl);
@ -791,11 +790,11 @@ static bool gl_core_init_filter_chain(gl_core_t *gl)
if (type != RARCH_SHADER_SLANG)
{
RARCH_LOG("[GLCore]: Only SLANG shaders are supported, falling back to stock.\n");
RARCH_WARN("[GLCore]: Only Slang shaders are supported, falling back to stock.\n");
return gl_core_init_default_filter_chain(gl);
}
if (!shader_path || !gl_core_init_filter_chain_preset(gl, shader_path))
if (!gl_core_init_filter_chain_preset(gl, shader_path))
gl_core_init_default_filter_chain(gl);
return true;
@ -1374,18 +1373,18 @@ static bool gl_core_set_shader(void *data,
return false;
gl_core_context_bind_hw_render(gl, false);
if (type != RARCH_SHADER_SLANG && path)
{
RARCH_WARN("[GLCore]: Only .slang or .slangp shaders are supported. Falling back to stock.\n");
gl_core_context_bind_hw_render(gl, true);
path = NULL;
}
if (gl->filter_chain)
gl_core_filter_chain_free(gl->filter_chain);
gl->filter_chain = NULL;
if (!path)
if (!string_is_empty(path) && type != RARCH_SHADER_SLANG)
{
RARCH_WARN("[GLCore]: Only Slang shaders are supported. Falling back to stock.\n");
path = NULL;
}
if (string_is_empty(path))
{
gl_core_init_default_filter_chain(gl);
gl_core_context_bind_hw_render(gl, true);
@ -1753,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;

41
gfx/drivers/gx2_gfx.c
View File

@ -450,13 +450,10 @@ static void *wiiu_gfx_init(const video_info_t *video,
video->is_threaded,
FONT_DRIVER_RENDER_WIIU);
if(settings->bools.video_shader_enable &&
!string_is_empty(retroarch_get_shader_preset()))
{
const char* ext = path_get_extension(retroarch_get_shader_preset());
if(ext && !strncmp(ext, "slang", 5))
wiiu_gfx_set_shader(wiiu, RARCH_SHADER_SLANG, retroarch_get_shader_preset());
const char *shader_preset = retroarch_get_shader_preset();
enum rarch_shader_type type = video_shader_parse_type(shader_preset);
wiiu_gfx_set_shader(wiiu, type, shader_preset);
}
return wiiu;
@ -1435,15 +1432,15 @@ static bool wiiu_gfx_set_shader(void *data,
GX2DrawDone();
wiiu_free_shader_preset(wiiu);
if (type != RARCH_SHADER_SLANG && path)
{
RARCH_WARN("Only .slang or .slangp shaders are supported. Falling back to stock.\n");
path = NULL;
}
if (!path)
if (string_is_empty(path))
return true;
if (type != RARCH_SHADER_SLANG)
{
RARCH_WARN("[GX2] Only Slang shaders are supported. Falling back to stock.\n");
return false;
}
if (!(conf = config_file_new(path)))
return false;
@ -1458,15 +1455,15 @@ static bool wiiu_gfx_set_shader(void *data,
video_shader_resolve_relative(wiiu->shader_preset, path);
#if 0
video_shader_resolve_parameters(conf, wiiu->shader_preset);
#else
for (int i = 0; i < wiiu->shader_preset->passes; i++)
slang_preprocess_parse_parameters(wiiu->shader_preset->pass[i].source.path, wiiu->shader_preset);
#if 0
video_shader_resolve_parameters(conf, wiiu->shader_preset);
#else
for (int i = 0; i < wiiu->shader_preset->passes; i++)
slang_preprocess_parse_parameters(wiiu->shader_preset->pass[i].source.path, wiiu->shader_preset);
video_shader_resolve_current_parameters(conf, wiiu->shader_preset);
#endif
config_file_free(conf);
video_shader_resolve_current_parameters(conf, wiiu->shader_preset);
#endif
config_file_free(conf);
for (int i = 0; i < wiiu->shader_preset->passes; i++)
{
@ -1546,7 +1543,6 @@ static bool wiiu_gfx_set_shader(void *data,
}
return true;
}
static struct video_shader *wiiu_gfx_get_current_shader(void *data)
@ -1720,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;

20
gfx/drivers/metal.m
View File

@ -69,12 +69,10 @@ static void *metal_init(const video_info_t *video,
return NULL;
}
const char *shader_path = retroarch_get_shader_preset();
if (shader_path)
{
enum rarch_shader_type type = video_shader_parse_type(shader_path, RARCH_SHADER_SLANG);
metal_set_shader(((__bridge void *)md), type, shader_path);
const char *shader_path = retroarch_get_shader_preset();
enum rarch_shader_type type = video_shader_parse_type(shader_path);
metal_set_shader((__bridge void *)md, type, shader_path);
}
return (__bridge_retained void *)md;
@ -127,15 +125,14 @@ static bool metal_set_shader(void *data,
{
#if defined(HAVE_SLANG) && defined(HAVE_SPIRV_CROSS)
MetalDriver *md = (__bridge MetalDriver *)data;
if (!md)
return false;
if (!path)
return true;
if (type != RARCH_SHADER_SLANG)
if (!string_is_empty(path) && type != RARCH_SHADER_SLANG)
{
RARCH_WARN("[Metal] Only .slang or .slangp shaders are supported. Falling back to stock.\n");
return false;
RARCH_WARN("[Metal] Only Slang shaders are supported. Falling back to stock.\n");
path = NULL;
}
return [md.frameView setShaderFromPath:[NSString stringWithUTF8String:path]];
@ -318,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;

24
gfx/drivers/vulkan.c
View File

@ -829,10 +829,9 @@ static bool vulkan_init_filter_chain_preset(vk_t *vk, const char *shader_path)
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);
enum rarch_shader_type type = video_shader_parse_type(shader_path, RARCH_SHADER_NONE);
if (type == RARCH_SHADER_NONE)
if (string_is_empty(shader_path))
{
RARCH_LOG("[Vulkan]: Loading stock shader.\n");
return vulkan_init_default_filter_chain(vk);
@ -840,7 +839,7 @@ static bool vulkan_init_filter_chain(vk_t *vk)
if (type != RARCH_SHADER_SLANG)
{
RARCH_LOG("[Vulkan]: Only SLANG shaders are supported, falling back to stock.\n");
RARCH_LOG("[Vulkan]: Only Slang shaders are supported, falling back to stock.\n");
return vulkan_init_default_filter_chain(vk);
}
@ -1359,17 +1358,17 @@ static bool vulkan_set_shader(void *data,
if (!vk)
return false;
if (type != RARCH_SHADER_SLANG && path)
{
RARCH_WARN("[Vulkan]: Only .slang or .slangp shaders are supported. Falling back to stock.\n");
path = NULL;
}
if (vk->filter_chain)
vulkan_filter_chain_free((vulkan_filter_chain_t*)vk->filter_chain);
vk->filter_chain = NULL;
if (!path)
if (!string_is_empty(path) && type != RARCH_SHADER_SLANG)
{
RARCH_WARN("[Vulkan]: Only Slang shaders are supported. Falling back to stock.\n");
path = NULL;
}
if (string_is_empty(path))
{
vulkan_init_default_filter_chain(vk);
return true;
@ -2397,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;

20
gfx/drivers_context/x_ctx.c
View File

@ -1150,32 +1150,26 @@ 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
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
{
#ifdef HAVE_CG
@ -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;
}

31
gfx/drivers_shader/shader_gl_cg.c
View File

@ -1074,16 +1074,27 @@ static void *gl_cg_init(void *data, const char *path)
memset(cg->alias_define, 0, sizeof(cg->alias_define));
if ( !string_is_empty(path)
&& string_is_equal(path_get_extension(path), "cgp"))
{
if (!gl_cg_load_preset(cg, path))
goto error;
}
else
{
if (!gl_cg_load_plain(cg, path))
goto error;
bool is_preset;
enum rarch_shader_type type =
video_shader_get_type_from_ext(path_get_extension(path), &is_preset);
if (!string_is_empty(path) && type != RARCH_SHADER_CG)
{
RARCH_ERR("[CG]: Invalid shader type, falling back to stock.\n");
path = NULL;
}
if (!string_is_empty(path) && is_preset)
{
if (!gl_cg_load_preset(cg, path))
goto error;
}
else
{
if (!gl_cg_load_plain(cg, path))
goto error;
}
}
cg->prg[0].mvp = cgGetNamedParameter(cg->prg[0].vprg, "IN.mvp_matrix");
@ -1099,7 +1110,7 @@ static void *gl_cg_init(void *data, const char *path)
cg->prg[cg->shader->passes + 1] = cg->prg[0];
/* No need to apply Android hack in Cg. */
cg->prg[VIDEO_SHADER_STOCK_BLEND] = cg->prg[0];
cg->prg[VIDEO_SHADER_STOCK_BLEND] = cg->prg[0];
gl_cg_set_shaders(cg->prg[1].fprg, cg->prg[1].vprg);

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;

65
gfx/drivers_shader/shader_glsl.c
View File

@ -888,44 +888,55 @@ static void *gl_glsl_init(void *data, const char *path)
if (!glsl->shader)
goto error;
if (!string_is_empty(path))
{
bool ret = false;
const char *path_ext = path_get_extension(path);
bool is_preset;
enum rarch_shader_type type =
video_shader_get_type_from_ext(path_get_extension(path), &is_preset);
if (string_is_equal(path_ext, "glslp"))
if (!string_is_empty(path) && type != RARCH_SHADER_GLSL)
{
conf = config_file_new(path);
if (conf)
RARCH_ERR("[GL]: Invalid shader type, falling back to stock.\n");
path = NULL;
}
if (!string_is_empty(path))
{
bool ret = false;
if (is_preset)
{
ret = video_shader_read_conf_preset(conf, glsl->shader);
conf = config_file_new(path);
if (conf)
{
ret = video_shader_read_conf_preset(conf, glsl->shader);
glsl->shader->modern = true;
}
}
else
{
strlcpy(glsl->shader->pass[0].source.path, path,
sizeof(glsl->shader->pass[0].source.path));
glsl->shader->passes = 1;
glsl->shader->modern = true;
ret = true;
}
if (!ret)
{
RARCH_ERR("[GL]: Failed to parse GLSL shader.\n");
goto error;
}
}
else if (string_is_equal(path_ext, "glsl"))
else
{
strlcpy(glsl->shader->pass[0].source.path, path,
sizeof(glsl->shader->pass[0].source.path));
RARCH_WARN("[GL]: Stock GLSL shaders will be used.\n");
glsl->shader->passes = 1;
glsl->shader->pass[0].source.string.vertex =
strdup(glsl_core ? stock_vertex_core : stock_vertex_modern);
glsl->shader->pass[0].source.string.fragment =
strdup(glsl_core ? stock_fragment_core : stock_fragment_modern);
glsl->shader->modern = true;
ret = true;
}
if (!ret)
{
RARCH_ERR("[GL]: Failed to parse GLSL shader.\n");
goto error;
}
}
else
{
RARCH_WARN("[GL]: Stock GLSL shaders will be used.\n");
glsl->shader->passes = 1;
glsl->shader->pass[0].source.string.vertex =
strdup(glsl_core ? stock_vertex_core : stock_vertex_modern);
glsl->shader->pass[0].source.string.fragment =
strdup(glsl_core ? stock_fragment_core : stock_fragment_modern);
glsl->shader->modern = true;
}
if (!string_is_empty(path))

4
gfx/drivers_shader/slang_process.cpp
View File

@ -482,7 +482,7 @@ bool slang_process(
}
else
#endif
if (dst_type == RARCH_SHADER_METAL)
if (dst_type == RARCH_SHADER_METAL)
{
CompilerMSL::Options options;
CompilerMSL* vs = (CompilerMSL*)vs_compiler;
@ -502,7 +502,7 @@ bool slang_process(
vs_code = vs->compile();
ps_code = ps->compile();
}
else if (shader_info->type == RARCH_SHADER_GLSL)
else if (dst_type == RARCH_SHADER_GLSL)
{
CompilerGLSL::Options options;
CompilerGLSL* vs = (CompilerGLSL*)vs_compiler;

144
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)
@ -730,7 +731,6 @@ bool video_shader_read_conf_preset(config_file_t *conf,
(void)file_list;
memset(shader, 0, sizeof(*shader));
shader->type = RARCH_SHADER_CG;
if (!config_get_uint(conf, "shaders", &shaders))
{
@ -1128,46 +1128,88 @@ void video_shader_write_conf_preset(config_file_t *conf,
}
}
const char *video_shader_to_str(enum rarch_shader_type type)
{
switch (type)
{
case RARCH_SHADER_CG:
return "Cg";
case RARCH_SHADER_HLSL:
return "HLSL";
case RARCH_SHADER_GLSL:
return "GLSL";
case RARCH_SHADER_SLANG:
return "Slang";
case RARCH_SHADER_METAL:
return "Metal";
case RARCH_SHADER_NONE:
return "none";
default:
break;
}
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)
{
gfx_ctx_flags_t flags;
enum display_flags flag = GFX_CTX_FLAGS_NONE;
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;
}
if (video_driver_get_all_flags(&flags, flag))
return true;
video_context_driver_get_flags(&flags);
return false;
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)
{
if (
video_shader_is_supported(RARCH_SHADER_SLANG) ||
video_shader_is_supported(RARCH_SHADER_HLSL) ||
video_shader_is_supported(RARCH_SHADER_GLSL) ||
video_shader_is_supported(RARCH_SHADER_CG)
)
return true;
return false;
return
video_shader_is_supported(RARCH_SHADER_SLANG) ||
video_shader_is_supported(RARCH_SHADER_HLSL) ||
video_shader_is_supported(RARCH_SHADER_GLSL) ||
video_shader_is_supported(RARCH_SHADER_CG);
}
enum rarch_shader_type video_shader_get_type_from_ext(const char *ext,
@ -1179,47 +1221,25 @@ enum rarch_shader_type video_shader_get_type_from_ext(const char *ext,
if (strlen(ext) > 1 && ext[0] == '.')
ext++;
if (
string_is_equal_case_insensitive(ext, "cgp") ||
string_is_equal_case_insensitive(ext, "glslp") ||
string_is_equal_case_insensitive(ext, "slangp")
*is_preset =
string_is_equal_case_insensitive(ext, "cgp") ||
string_is_equal_case_insensitive(ext, "glslp") ||
string_is_equal_case_insensitive(ext, "slangp");
if (string_is_equal_case_insensitive(ext, "cgp") ||
string_is_equal_case_insensitive(ext, "cg")
)
*is_preset = true;
else
*is_preset = false;
return RARCH_SHADER_CG;
{
gfx_ctx_flags_t flags;
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;
}
}
if (string_is_equal_case_insensitive(ext, "glslp") ||
string_is_equal_case_insensitive(ext, "glsl")
)
return RARCH_SHADER_GLSL;
{
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;
}
}
if (string_is_equal_case_insensitive(ext, "slangp") ||
string_is_equal_case_insensitive(ext, "slang")
)
return RARCH_SHADER_SLANG;
return RARCH_SHADER_NONE;
}
@ -1227,22 +1247,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);
}
/**

15
gfx/video_shader_parse.h
View File

@ -141,8 +141,6 @@ struct video_shader_lut
* Avoid lots of allocation for convenience. */
struct video_shader
{
enum rarch_shader_type type;
char prefix[64];
char script_class[512];
char script_path[PATH_MAX_LENGTH];
@ -233,16 +231,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);
@ -253,6 +248,10 @@ bool video_shader_any_supported(void);
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

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_shader_is_supported(RARCH_SHADER_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_shader_is_supported(RARCH_SHADER_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_shader_is_supported(RARCH_SHADER_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_shader_is_supported(RARCH_SHADER_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_shader_is_supported(RARCH_SHADER_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_shader_is_supported(RARCH_SHADER_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_shader_is_supported(RARCH_SHADER_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_shader_is_supported(RARCH_SHADER_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_shader_is_supported(RARCH_SHADER_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, "|");

176
menu/menu_setting.c
View File

@ -5685,7 +5685,7 @@ void general_write_handler(rarch_setting_t *setting)
menu_entries_ctl(MENU_ENTRIES_CTL_SET_REFRESH, &refresh);
menu_driver_ctl(RARCH_MENU_CTL_SET_PREVENT_POPULATE, NULL);
}
else if (!*setting->value.target.boolean)
else
{
bool refresh = false;
settings_t *settings = config_get_ptr();
@ -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,

44
menu/menu_shader.c
View File

@ -147,14 +147,14 @@ bool menu_shader_manager_init(void)
* Sets shader preset.
**/
bool menu_shader_manager_set_preset(void *data,
unsigned type, const char *preset_path)
enum rarch_shader_type type, const char *preset_path)
{
struct video_shader *shader = (struct video_shader*)data;
config_file_t *conf = NULL;
bool refresh = false;
settings_t *settings = config_get_ptr();
if (!video_driver_set_shader((enum rarch_shader_type)type, preset_path))
if (!video_driver_set_shader(type, preset_path))
{
configuration_set_bool(settings, settings->bools.video_shader_enable, false);
return false;
@ -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
@ -225,7 +209,8 @@ bool menu_shader_manager_save_preset(
char preset_path[PATH_MAX_LENGTH];
char config_directory[PATH_MAX_LENGTH];
bool ret = false;
unsigned d, type = RARCH_SHADER_NONE;
unsigned d;
enum rarch_shader_type type = RARCH_SHADER_NONE;
const char *dirs[3] = {0};
config_file_t *conf = NULL;
struct video_shader *shader = menu_shader_get();
@ -254,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));
}
@ -265,12 +250,12 @@ bool menu_shader_manager_save_preset(
default_preset[0] = '\0';
if (video_shader_is_supported((enum rarch_shader_type)type))
if (video_shader_is_supported(type))
{
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))
{
@ -449,30 +434,29 @@ void menu_shader_manager_clear_pass_path(unsigned i)
*
* Returns: type of shader.
**/
unsigned menu_shader_manager_get_type(const void *data)
enum rarch_shader_type menu_shader_manager_get_type(const void *data)
{
unsigned type = RARCH_SHADER_NONE;
const struct video_shader *shader = (const struct video_shader*)data;
/* All shader types must be the same, or we cannot use it. */
uint8_t i = 0;
unsigned i = 0;
if (!shader)
return RARCH_SHADER_NONE;
type = video_shader_parse_type(shader->path);
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)
{
case RARCH_SHADER_CG:
case RARCH_SHADER_GLSL:
case RARCH_SHADER_SLANG:
if (type == RARCH_SHADER_NONE)
type = pass_type;
else if (type != pass_type)
if (type != pass_type)
return RARCH_SHADER_NONE;
break;
default:
@ -490,7 +474,7 @@ unsigned menu_shader_manager_get_type(const void *data)
**/
void menu_shader_manager_apply_changes(void)
{
unsigned shader_type;
enum rarch_shader_type shader_type;
struct video_shader *shader = menu_shader_get();
if (!shader)

5
menu/menu_shader.h
View File

@ -20,6 +20,7 @@
#include <retro_common_api.h>
#include "../retroarch.h"
#include "../gfx/video_shader_parse.h"
RETRO_BEGIN_DECLS
@ -43,7 +44,7 @@ bool menu_shader_manager_init(void);
* Sets shader preset.
**/
bool menu_shader_manager_set_preset(
void *data, unsigned type, const char *preset_path);
void *data, enum rarch_shader_type type, const char *preset_path);
/**
* menu_shader_manager_save_preset:
@ -63,7 +64,7 @@ bool menu_shader_manager_save_preset(
*
* Returns: type of shader.
**/
unsigned menu_shader_manager_get_type(const void *data);
enum rarch_shader_type menu_shader_manager_get_type(const void *data);
/**
* menu_shader_manager_apply_changes:

161
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;
@ -10026,10 +10027,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 +10172,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;
@ -13757,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)
{
@ -13764,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;
}

8
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,
@ -2026,8 +2027,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_shader_is_supported(RARCH_SHADER_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_shader_is_supported(RARCH_SHADER_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_shader_is_supported(RARCH_SHADER_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_shader_is_supported(RARCH_SHADER_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_shader_is_supported(RARCH_SHADER_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_shader_is_supported(RARCH_SHADER_SLANG))
filter += QLatin1Literal(" *.slang");
filter += ")";