Emulation/RetroArch
1
0
Fork 0
mirror of https://github.com/libretro/RetroArch.git synced 2024-06-02 19:57:24 -04:00
Code Issues Packages Projects Releases Wiki Activity

Shader Preset - Wildcard Replacement in Paths on Load (#15023)

Browse source 
When a simple preset loads, wildcards which are found in paths inside the presets will 
be replaced with values coming from the current RetroArch context.  This will operate
on both texture paths and reference paths.

This would allow you to do things like have one preset which could be used with the entire list of images from the Bezel Project

E.G. 
    "/shaders/MyBackground_$VID-DRV$ _$CORE$.png" 
would be replaced with
   "/shaders/MyBackground_glcore_YabaSanshiro.png"
If  no file found at that path, the path will revert to the original path, so operates as a fallback
   "/shaders/MyBackground_$VID-DRV$ _$CORE$.png" 

  * Possible wildcards/tokens to be replaced:
 * 
 *   $CONTENT-DIR$ -> Content Directory of the game rom
 * 
 *   $CORE$       -> Core name
 * 
 *   $GAME$       -> Game ROM's name
 * 
 *   $VID-DRV$   -> Video Driver: Currently active driver, possible replacement values:
 *       glcore
 *       gl
 *       vulkan
 *       d3d11
 *       d3d9_hlsl
 *       "N/A"
 * 
 *   $VID-DRV-SHADER-EXT$   -> Video Driver Shader File Extension: The extension of shaders type supported by the current video driver:
 *       cg
 *       glsl
 *       slang
 * 
 *   $VID-DRV-PRESET-EXT$   -> Video Driver Preset File Extension: The extension of shaders type supported by the current video driver:
 *       cgp
 *       glslp
 *       slangp
 * 
 *   $CORE-REQ-ROT$   -> Core Requested Rotation: Rotation the core is requesting, possible replacement values:
 *       CORE-REQ-ROT-0
 *       CORE-REQ-ROT-90
 *       CORE-REQ-ROT-180
 *       CORE-REQ-ROT-270
 * 
 *   $VID-ALLOW-CORE-ROT$   -> Video Allow Core Rotation: Reflects Retroarch's setting allowing the core requested rotation to affect the final rotation:
 *       VID-ALLOW-CORE-ROT-OFF
 *       VID-ALLOW-CORE-ROT-ON
 * 
 *   $VID-USER-ROT$   -> Video User Rotation: Rotation the core is requesting, possible replacement values, does not affect the UI:
 *       VID-USER-ROT-0
 *       VID-USER-ROT-90
 *       VID-USER-ROT-180
 *       VID-USER-ROT-270
 * 
 *   $VID-FINAL-ROT$   -> Video Final Rotation: Rotation which is the sum of the user rotation and the core rotation if it has been allowed, does not affect the UI:
 *       VID-FINAL-ROT-0
 *       VID-FINAL-ROT-90
 *       VID-FINAL-ROT-180
 *       VID-FINAL-ROT-270
 * 
 *   $SCREEN-ORIENT$   -> Screen Orientation: User adjusted screen orientation, will change windows from landscape to portrait, including the Retroarch UI:
 *       SCREEN-ORIENT-0
 *       SCREEN-ORIENT-90
 *       SCREEN-ORIENT-180
 *       SCREEN-ORIENT-270
 * 
 *   $VIEW-ASPECT-ORIENT$   -> Viewport Aspect Orientation: Orientation of the aspect ratio of the RetroArch viewport
 *       VIEW-ASPECT-ORIENT-HORZ
 *       VIEW-ASPECT-ORIENT-VERT
 * 
 *   $CORE-ASPECT-ORIENT$   -> Core Aspect Orientation: Orientation of the aspect ratio requested by the core
 *       CORE-ASPECT-ORIENT-HORZ
 *       CORE-ASPECT-ORIENT-VERT
 * 
 *   $PRESET_DIR$  -> Preset directory's name
 * 
 *   $PRESET$     -> Preset's name
 * 
 * If no wildcards are found within the path, or the path 
 * after replacing the wildcards does not exist on disk,
 * the path returned will be unaffected.
This commit is contained in:
HyperspaceMadness 2023-02-26 13:06:57 -05:00 committed by GitHub
parent a2f34a6836
commit e4a11cff59
No known key found for this signature in database
GPG key ID: 4AEE18F83AFDEB23
7 changed files with 456 additions and 39 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

20
gfx/video_driver.c
View file

@ -2019,20 +2019,30 @@ bool video_driver_supports_read_frame_raw(void)
return false;
}
void video_driver_set_viewport_core(void)
/* Get aspect ratio (DAR) requested by the core */
float video_driver_get_core_aspect(void)
{
video_driver_state_t *video_st = &video_driver_st;
struct retro_game_geometry *geom = &video_st->av_info.geometry;
float out_aspect = 0;
if (!geom || geom->base_width <= 0.0f || geom->base_height <= 0.0f)
return;
return out_aspect;
/* Fallback to 1:1 pixel ratio if none provided */
if (geom->aspect_ratio > 0.0f)
aspectratio_lut[ASPECT_RATIO_CORE].value = geom->aspect_ratio;
out_aspect = geom->aspect_ratio;
else
aspectratio_lut[ASPECT_RATIO_CORE].value =
(float)geom->base_width / geom->base_height;
out_aspect = (float)geom->base_width / geom->base_height;
return out_aspect;
}
void video_driver_set_viewport_core(void)
{
float core_aspect = video_driver_get_core_aspect();
if (core_aspect != 0)
aspectratio_lut[ASPECT_RATIO_CORE].value = core_aspect;
}
void video_driver_set_rgba(void)

2
gfx/video_driver.h
View file

@ -911,6 +911,8 @@ bool video_driver_prefer_viewport_read(void);
bool video_driver_supports_read_frame_raw(void);
float video_driver_get_core_aspect(void);
void video_driver_set_viewport_core(void);
void video_driver_reset_custom_viewport(settings_t *settings);

403
gfx/video_shader_parse.c
View file

@ -59,6 +59,25 @@
/* Maximum depth of chain of referenced shader presets.
* 16 seems to be a very large number of references at the moment. */
#define SHADER_MAX_REFERENCE_DEPTH 16
#define SHADER_NUM_WILDCARDS 15
struct wildcard_token wildcard_tokens[SHADER_NUM_WILDCARDS] = {
{RARCH_WILDCARD_CONTENT_DIR, "$CONTENT-DIR$"},
{RARCH_WILDCARD_CORE, "$CORE$"},
{RARCH_WILDCARD_GAME, "$GAME$"},
{RARCH_WILDCARD_VIDEO_DRIVER, "$VID-DRV$"},
{RARCH_WILDCARD_VIDEO_DRIVER_PRESET_EXT, "$VID-DRV-PRESET-EXT$"},
{RARCH_WILDCARD_VIDEO_DRIVER_SHADER_EXT, "$VID-DRV-SHADER-EXT$"},
{RARCH_WILDCARD_CORE_REQUESTED_ROTATION, "$CORE-REQ-ROT$"},
{RARCH_WILDCARD_VIDEO_ALLOW_CORE_ROTATION, "$VID-ALLOW-CORE-ROT$"},
{RARCH_WILDCARD_VIDEO_USER_ROTATION, "$VID-USER-ROT$"},
{RARCH_WILDCARD_VIDEO_FINAL_ROTATION, "$VID-FINAL-ROT$"},
{RARCH_WILDCARD_SCREEN_ORIENTATION, "$SCREEN-ORIENT$"},
{RARCH_WILDCARD_VIEWPORT_ASPECT_ORIENTATION, "$VIEW-ASPECT-ORIENT$"},
{RARCH_WILDCARD_CORE_ASPECT_ORIENTATION, "$CORE-ASPECT-ORIENT$"},
{RARCH_WILDCARD_PRESET_DIR, "$PRESET-DIR$"},
{RARCH_WILDCARD_PRESET, "$PRESET$"},
};
/* TODO/FIXME - global state - perhaps move outside this file */
static path_change_data_t *file_change_data = NULL;
@ -81,7 +100,8 @@ static path_change_data_t *file_change_data = NULL;
* out_path is filled with the absolute path
**/
static void fill_pathname_expanded_and_absolute(char *out_path,
const char *in_refpath, const char *in_path)
const char *in_refpath,
const char *in_path)
{
char expanded_path[PATH_MAX_LENGTH];
@ -101,6 +121,313 @@ static void fill_pathname_expanded_and_absolute(char *out_path,
pathname_conform_slashes_to_os(out_path);
}
/**
* replace_wildcards:
*
* @param inout_absolute_path
* Absolute path to replace wildcards in
*
* @param in_preset_path
* Path of the preset that this path is being used in
*
* All the wildcards are replaced by the live values which come from retroarch
* or the preset context
*
* Possible wildcards/tokens to be replaced:
*
* $CONTENT-DIR$ -> Content Directory of the game rom
*
* $CORE$ -> Core name
*
* $GAME$ -> Game ROM's name
*
* $VID-DRV$ -> Video Driver: Currently active driver, possible replacement values:
* glcore
* gl
* vulkan
* d3d11
* d3d9_hlsl
* "N/A"
*
* $VID-DRV-SHADER-EXT$ -> Video Driver Shader File Extension: The extension of shaders type supported by the current video driver:
* cg
* glsl
* slang
*
* $VID-DRV-PRESET-EXT$ -> Video Driver Preset File Extension: The extension of shaders type supported by the current video driver:
* cgp
* glslp
* slangp
*
* $CORE-REQ-ROT$ -> Core Requested Rotation: Rotation the core is requesting, possible replacement values:
* CORE-REQ-ROT-0
* CORE-REQ-ROT-90
* CORE-REQ-ROT-180
* CORE-REQ-ROT-270
*
* $VID-ALLOW-CORE-ROT$ -> Video Allow Core Rotation: Reflect's Retroarch's setting allowing the core requested rotation to affect the final rotation:
* VID-ALLOW-CORE-ROT-OFF
* VID-ALLOW-CORE-ROT-ON
*
* $VID-USER-ROT$ -> Video User Rotation: Rotation the core is requesting, possible replacement values, does not affect the UI:
* VID-USER-ROT-0
* VID-USER-ROT-90
* VID-USER-ROT-180
* VID-USER-ROT-270
*
* $VID-FINAL-ROT$ -> Video Final Rotation: Rotation which is the sum of the user rotation and the core rotation if it has been allowed, does not affect the UI:
* VID-FINAL-ROT-0
* VID-FINAL-ROT-90
* VID-FINAL-ROT-180
* VID-FINAL-ROT-270
*
* $SCREEN-ORIENT$ -> Screen Orientation: User adjusted screen orientation, will change windows from landscape to portrait, including the Retroarch UI:
* SCREEN-ORIENT-0
* SCREEN-ORIENT-90
* SCREEN-ORIENT-180
* SCREEN-ORIENT-270
*
* $VIEW-ASPECT-ORIENT$ -> Viewport Aspect Orientation: Orientation of the aspect ratio of the retroarch viewport
* VIEW-ASPECT-ORIENT-HORZ
* VIEW-ASPECT-ORIENT-VERT
*
* $CORE-ASPECT-ORIENT$ -> Core Aspect Orientation: Orientation of the aspect ratio requested by the core
* CORE-ASPECT-ORIENT-HORZ
* CORE-ASPECT-ORIENT-VERT
*
* $PRESET_DIR$ -> Preset directory's name
*
* $PRESET$ -> Preset's name
*
* If no wildcards are found within the path, or the path
* after replacing the wildcards does not exist on disk,
* the path returned will be uneffected.
**/
static void replace_wildcards(char *inout_absolute_path, const unsigned in_absolute_path_length, char *in_preset_path)
{
int i = 0;
char replaced_path[PATH_MAX_LENGTH] = "";
if (!strstr(inout_absolute_path, RARCH_WILDCARD_DELIMITER))
return;
strlcpy(replaced_path, inout_absolute_path, sizeof(replaced_path));
/* Step through the wildcards while we can still find the
* delimiter in the replaced path
*/
for (i = 0; (i < SHADER_NUM_WILDCARDS) && (strstr(replaced_path, RARCH_WILDCARD_DELIMITER)); i++)
{
/* If the wildcard text is in the path then process it */
if (strstr(replaced_path, wildcard_tokens[i].token_name))
{
char replace_text[PATH_MAX_LENGTH] = "";
switch (wildcard_tokens[i].token_id)
{
case RARCH_WILDCARD_CONTENT_DIR:
{
char content_dir_name[PATH_MAX_LENGTH] = "";
const char* rarch_path_basename = path_get(RARCH_PATH_BASENAME);
if (rarch_path_basename)
{
fill_pathname_parent_dir_name(content_dir_name,
rarch_path_basename,
sizeof(content_dir_name));
}
if (string_is_not_equal_fast(content_dir_name, "", sizeof("")))
{
strlcpy(content_dir_name,
path_basename_nocompression(content_dir_name),
sizeof(content_dir_name));
}
if (string_is_not_equal_fast(content_dir_name, "", sizeof("")))
path_remove_extension(content_dir_name);
if (string_is_not_equal_fast(content_dir_name, "", sizeof("")))
strlcpy(replace_text, content_dir_name, sizeof(replace_text));
break;
}
case RARCH_WILDCARD_CORE:
{
runloop_state_t* runloop_st = runloop_state_get_ptr();
strlcpy(replace_text, runloop_st->system.info.library_name, sizeof(replace_text));
break;
}
case RARCH_WILDCARD_GAME:
{
const char* path_basename = path_get(RARCH_PATH_BASENAME);
if (path_basename)
path_basename = path_basename_nocompression(path_basename);
if (path_basename)
strlcpy(replace_text, path_basename, sizeof(replace_text));
break;
}
case RARCH_WILDCARD_VIDEO_DRIVER:
{
strlcpy(replace_text, config_get_ptr()->arrays.video_driver, sizeof(replace_text));
break;
}
case RARCH_WILDCARD_CORE_REQUESTED_ROTATION:
{
char rotation_replace_strings[4][PATH_MAX_LENGTH] = {
"CORE-REQ-ROT-0",
"CORE-REQ-ROT-90",
"CORE-REQ-ROT-180",
"CORE-REQ-ROT-270"
};
strlcpy(replace_text, rotation_replace_strings[retroarch_get_core_requested_rotation()], sizeof(replace_text));
break;
}
case RARCH_WILDCARD_VIDEO_ALLOW_CORE_ROTATION:
{
if (config_get_ptr()->bools.video_allow_rotate)
strlcpy(replace_text, "VID-ALLOW-CORE-ROT-ON", sizeof(replace_text));
else
strlcpy(replace_text, "VID-ALLOW-CORE-ROT-OFF", sizeof(replace_text));
break;
}
case RARCH_WILDCARD_VIDEO_USER_ROTATION:
{
char rotation_replace_strings[4][PATH_MAX_LENGTH] = {
"VID-USER-ROT-0",
"VID-USER-ROT-90",
"VID-USER-ROT-180",
"VID-USER-ROT-270"
};
strlcpy(replace_text, rotation_replace_strings[retroarch_get_video_rotation()], sizeof(replace_text));
break;
}
case RARCH_WILDCARD_VIDEO_FINAL_ROTATION:
{
char rotation_replace_strings[4][PATH_MAX_LENGTH] = {
"VID-FINAL-ROT-0",
"VID-FINAL-ROT-90",
"VID-FINAL-ROT-180",
"VID-FINAL-ROT-270"
};
strlcpy(replace_text, rotation_replace_strings[retroarch_get_rotation()], sizeof(replace_text));
break;
}
case RARCH_WILDCARD_SCREEN_ORIENTATION:
{
char rotation_replace_strings[4][PATH_MAX_LENGTH] = {
"SCREEN-ORIENT-0",
"SCREEN-ORIENT-90",
"SCREEN-ORIENT-180",
"SCREEN-ORIENT-270"
};
strlcpy(replace_text, rotation_replace_strings[config_get_ptr()->uints.screen_orientation], sizeof(replace_text));
break;
}
case RARCH_WILDCARD_CORE_ASPECT_ORIENTATION:
{
const int requested_rotation = retroarch_get_core_requested_rotation();
strlcpy(replace_text, (video_driver_get_core_aspect() < 1 || requested_rotation == 1 || requested_rotation == 3) ?
"CORE-ASPECT-ORIENT-VERT" :
"CORE-ASPECT-ORIENT-HORZ",
sizeof(replace_text));
break;
}
case RARCH_WILDCARD_VIEWPORT_ASPECT_ORIENTATION:
{
unsigned viewport_width = 0;
unsigned viewport_height = 0;
video_driver_get_size(&viewport_width, &viewport_height);
strlcpy(replace_text, ((float)viewport_width / viewport_height < 1) ?
"VIEW-ASPECT-ORIENT-VERT" :
"VIEW-ASPECT-ORIENT-HORZ",
sizeof(replace_text));
break;
}
case RARCH_WILDCARD_PRESET_DIR:
{
char preset_dir_name[PATH_MAX_LENGTH] = "";
fill_pathname_parent_dir_name(preset_dir_name, in_preset_path, sizeof(preset_dir_name));
if (string_is_not_equal_fast(preset_dir_name, "", sizeof("")))
strlcpy(preset_dir_name, path_basename_nocompression(preset_dir_name), sizeof(preset_dir_name));
if (string_is_not_equal_fast(preset_dir_name, "", sizeof("")))
path_remove_extension(preset_dir_name);
if (string_is_not_equal_fast(preset_dir_name, "", sizeof("")))
strlcpy(replace_text, preset_dir_name, sizeof(replace_text));
break;
}
case RARCH_WILDCARD_PRESET:
{
char preset_name[PATH_MAX_LENGTH] = "";
strlcpy(preset_name, path_basename_nocompression(in_preset_path), sizeof(preset_name));
if (string_is_not_equal_fast(preset_name, "", sizeof("")))
path_remove_extension(preset_name);
if (string_is_not_equal_fast(preset_name, "", sizeof("")))
strlcpy(replace_text, preset_name, sizeof(replace_text));
break;
}
case RARCH_WILDCARD_VIDEO_DRIVER_SHADER_EXT:
{
if (video_shader_is_supported(RARCH_SHADER_CG))
strlcpy(replace_text, "cg", sizeof(replace_text));
else if (video_shader_is_supported(RARCH_SHADER_GLSL))
strlcpy(replace_text, "glsl", sizeof(replace_text));
else if (video_shader_is_supported(RARCH_SHADER_SLANG))
strlcpy(replace_text, "slang", sizeof(replace_text));
break;
}
case RARCH_WILDCARD_VIDEO_DRIVER_PRESET_EXT:
{
if (video_shader_is_supported(RARCH_SHADER_CG))
strlcpy(replace_text, "cgp", sizeof(replace_text));
else if (video_shader_is_supported(RARCH_SHADER_GLSL))
strlcpy(replace_text, "glslp", sizeof(replace_text));
else if (video_shader_is_supported(RARCH_SHADER_SLANG))
strlcpy(replace_text, "slangp", sizeof(replace_text));
break;
}
}
{
char *replace_output = NULL;
replace_output = string_replace_substring(replaced_path,
wildcard_tokens[i].token_name, strlen(wildcard_tokens[i].token_name),
replace_text, strlen(replace_text));
strlcpy(replaced_path, replace_output, PATH_MAX_LENGTH);
free(replace_output);
}
}
}
/* If a file does not exist at the location of the replaced path
* then output the original path instead */
if (!path_is_valid(replaced_path))
{
RARCH_DBG("\n[Shaders]: Filepath after wildcard replacement can't be found:\n");
RARCH_DBG(" \"%s\" \n", replaced_path);
RARCH_DBG(" Falling back to original Filepath\n");
RARCH_DBG(" \"%s\" \n\n", inout_absolute_path);
}
else
{
strlcpy(inout_absolute_path, replaced_path, in_absolute_path_length);
}
return;
}
/**
* gather_reference_path_list:
*
* @param path_linked_list
* List of paths which accrues as we move down the chain of references
* @param path
* Current path of preset to process
* @param reference_depth
* This is used to check against the SHADER_MAX_REFERENCE_DEPTH
*
* @return void
**/
static void gather_reference_path_list(
struct path_linked_list *in_path_linked_list,
char *path,
@ -118,7 +445,10 @@ static void gather_reference_path_list(
{
char* reference_preset_path = (char*)malloc(PATH_MAX_LENGTH);
/* Get the absolute path and replace wildcards in the path */
fill_pathname_expanded_and_absolute(reference_preset_path, conf->path, ref_tmp->path);
replace_wildcards(reference_preset_path, PATH_MAX_LENGTH, conf->path);
gather_reference_path_list(in_path_linked_list, reference_preset_path, reference_depth + 1);
free(reference_preset_path);
@ -128,7 +458,7 @@ static void gather_reference_path_list(
}
else
{
RARCH_WARN("\n [Shaders]: No Preset located at \"%s\".\n", path);
RARCH_WARN("\n[Shaders]: No Preset located at \"%s\".\n", path);
}
config_file_free(conf);
}
@ -240,9 +570,9 @@ static bool video_shader_parse_pass(config_file_t *conf,
return false;
}
/* Get the absolute path */
fill_pathname_expanded_and_absolute(pass->source.path,
conf->path, tmp_path);
/* Get the absolute path and replace wildcards in the path */
fill_pathname_expanded_and_absolute(pass->source.path, conf->path, tmp_path);
replace_wildcards(pass->source.path, PATH_MAX_LENGTH, conf->path);
/* Smooth */
strlcpy(filter_name_buf, "filter_linear", sizeof(filter_name_buf));
@ -481,9 +811,9 @@ static bool video_shader_parse_textures(config_file_t *conf,
config_get_path(conf, id, texture_path, sizeof(texture_path));
/* Get the absolute path */
fill_pathname_expanded_and_absolute(
shader->lut[shader->luts].path, conf->path, texture_path);
/* Get the absolute path and replace wildcards in the path */
fill_pathname_expanded_and_absolute(shader->lut[shader->luts].path, conf->path, texture_path);
replace_wildcards(shader->lut[shader->luts].path, PATH_MAX_LENGTH, conf->path);
entry = NULL;
@ -537,7 +867,7 @@ static struct video_shader_parameter *video_shader_parse_find_parameter(
{
size_t i;
for (i = 0; i < num_params; i++)
for (i = 0; (unsigned)i < num_params; i++)
{
if (string_is_equal(params[i].id, id))
return &params[i];
@ -964,8 +1294,9 @@ static config_file_t *video_shader_get_root_preset_config(const char *path)
return NULL;
}
/* Get the absolute path for the reference */
fill_pathname_expanded_and_absolute(nested_reference_path, conf->path, conf->references->path);
/* Get the absolute path and replace wildcards in the path */
fill_pathname_expanded_and_absolute(nested_reference_path, conf->path, conf->references->path);
replace_wildcards(nested_reference_path, PATH_MAX_LENGTH, conf->path);
/* Create a new config from the referenced path */
config_file_free(conf);
@ -1049,8 +1380,9 @@ static bool video_shader_check_reference_chain_for_save(
break;
}
/* Get the absolute path for the reference */
/* Get the absolute path and replace wildcards in the path */
fill_pathname_expanded_and_absolute(nested_ref_path, conf->path, conf->references->path);
replace_wildcards(nested_ref_path, PATH_MAX_LENGTH, conf->path);
/* If one of the reference paths is the same as the file we want to save then this reference chain would be
* self-referential / cyclical and we can't save this as a simple preset*/
@ -1194,9 +1526,9 @@ static bool video_shader_write_referenced_preset(
* trying to save */
if (ref_conf->references)
{
/* Get the absolute path for the reference */
fill_pathname_expanded_and_absolute(abs_tmp_ref_path,
ref_conf->path, ref_conf->references->path);
/* Get the absolute path and replace wildcards in the path */
fill_pathname_expanded_and_absolute(abs_tmp_ref_path, ref_conf->path, ref_conf->references->path);
replace_wildcards(abs_tmp_ref_path, PATH_MAX_LENGTH, ref_conf->path);
pathname_conform_slashes_to_os(abs_tmp_ref_path);
@ -1234,9 +1566,9 @@ static bool video_shader_write_referenced_preset(
* we will use this same nested reference for the new preset */
if (ref_conf->references)
{
/* Get the absolute path for the reference */
fill_pathname_expanded_and_absolute(path_to_ref,
ref_conf->path, ref_conf->references->path);
/* Get the absolute path and replace wildcards in the path */
fill_pathname_expanded_and_absolute(path_to_ref, ref_conf->path, ref_conf->references->path);
replace_wildcards(path_to_ref, PATH_MAX_LENGTH, ref_conf->path);
/* If the reference path is also the same as what
* we are trying to save
@ -1254,8 +1586,11 @@ static bool video_shader_write_referenced_preset(
/* If the reference also has a reference inside it */
/* Get the absolute path for the reference */
if (ref_conf->references)
fill_pathname_expanded_and_absolute(path_to_ref,
ref_conf->path, ref_conf->references->path);
{
/* Get the absolute path and replace wildcards in the path */
fill_pathname_expanded_and_absolute(path_to_ref, ref_conf->path, ref_conf->references->path);
replace_wildcards(path_to_ref, PATH_MAX_LENGTH, ref_conf->path);
}
else
{
/* If the config referenced is a full preset */
@ -1721,8 +2056,6 @@ static bool override_shader_values(config_file_t *override_conf,
{
char *override_tex_path = (char*)malloc(PATH_MAX_LENGTH);
override_tex_path[0] = '\0';
/* Step through the textures in the shader and see if there is an entry
* for each in the override config */
for (i = 0; i < shader->luts; i++)
@ -1730,13 +2063,16 @@ static bool override_shader_values(config_file_t *override_conf,
/* If the texture is defined in the reference config */
if (config_get_entry(override_conf, shader->lut[i].id))
{
/* Texture path from shader the config */
config_get_path(override_conf, shader->lut[i].id,
override_tex_path, PATH_MAX_LENGTH);
char *tex_path = (char*)malloc(PATH_MAX_LENGTH);
/* Get the absolute path */
fill_pathname_expanded_and_absolute(shader->lut[i].path,
override_conf->path, override_tex_path);
/* Texture path from the config */
config_get_path(override_conf, shader->lut[i].id, tex_path, PATH_MAX_LENGTH);
/* Get the absolute path and replace wildcards in the path */
fill_pathname_expanded_and_absolute(override_tex_path, override_conf->path, tex_path);
replace_wildcards(override_tex_path, PATH_MAX_LENGTH, override_conf->path);
strlcpy(shader->lut[i].path, override_tex_path, PATH_MAX_LENGTH);
#ifdef DEBUG
RARCH_DBG("[Shaders]: Texture: \"%s\" = %s.\n",
@ -1744,6 +2080,7 @@ static bool override_shader_values(config_file_t *override_conf,
shader->lut[i].path);
#endif
free(tex_path);
return_val = true;
}
}
@ -1953,8 +2290,8 @@ bool video_shader_load_preset_into_shader(const char *path,
goto end;
}
/* Check if the root preset is a valid shader chain */
/* If the config has a shaders entry then it is considered
/* Check if the root preset is a valid shader chain
If the config has a shaders entry then it is considered
a shader chain config, vs a config which may only have
parameter values and texture overrides
*/
@ -1994,12 +2331,14 @@ bool video_shader_load_preset_into_shader(const char *path,
config_file_t *tmp_conf = NULL;
char *path_to_ref = (char*)malloc(PATH_MAX_LENGTH);
/* Get the absolute path and replace wildcards in the path */
fill_pathname_expanded_and_absolute(path_to_ref, conf->path, path_list_tmp->path);
replace_wildcards(path_to_ref, PATH_MAX_LENGTH, conf->path);
if ((tmp_conf = video_shader_get_root_preset_config(path_to_ref)))
{
/* Check if the config is a valid shader chain config */
/* If the config has a shaders entry then it is considered
/* Check if the config is a valid shader chain config
If the config has a shaders entry then it is considered
a shader chain config, vs a config which may only have
parameter values and texture overrides
*/

27
gfx/video_shader_parse.h
View file

@ -188,6 +188,33 @@ struct video_shader
};
#define RARCH_WILDCARD_DELIMITER "$"
enum wildcard_type
{
RARCH_WILDCARD_CONTENT_DIR = 0,
RARCH_WILDCARD_CORE,
RARCH_WILDCARD_GAME,
RARCH_WILDCARD_VIDEO_DRIVER,
RARCH_WILDCARD_VIDEO_USER_ROTATION,
RARCH_WILDCARD_VIDEO_ALLOW_CORE_ROTATION,
RARCH_WILDCARD_CORE_REQUESTED_ROTATION,
RARCH_WILDCARD_VIDEO_FINAL_ROTATION,
RARCH_WILDCARD_SCREEN_ORIENTATION,
RARCH_WILDCARD_VIEWPORT_ASPECT_ORIENTATION,
RARCH_WILDCARD_CORE_ASPECT_ORIENTATION,
RARCH_WILDCARD_PRESET_DIR,
RARCH_WILDCARD_PRESET,
RARCH_WILDCARD_VIDEO_DRIVER_SHADER_EXT,
RARCH_WILDCARD_VIDEO_DRIVER_PRESET_EXT
};
struct wildcard_token
{
enum wildcard_type token_id;
char token_name[64];
};
/**
* video_shader_resolve_parameters:

15
retroarch.h
View file

@ -143,6 +143,21 @@ const char* config_get_audio_driver_options(void);
/* Camera */
/*
Returns the user defined video rotation set in the video_rotation user setting
*/
unsigned int retroarch_get_video_rotation(void);
/*
Returns rotation requested by the core regardless of if it has been
applied with the final video rotation
*/
unsigned int retroarch_get_core_requested_rotation(void);
/*
Returns final rotation including both user chosen video rotation
and core requested rotation if allowed by video_allow_rotate
*/
unsigned int retroarch_get_rotation(void);
void retroarch_init_task_queue(void);

1
retroarch_types.h
View file

@ -180,6 +180,7 @@ typedef struct rarch_system_info
unsigned size;
} ports;
unsigned rotation;
unsigned core_requested_rotation;
unsigned performance_level;
char valid_extensions[255];
bool load_no_content;

27
runloop.c
View file

@ -1897,6 +1897,8 @@ bool runloop_environment_cb(unsigned cmd, void *data)
bool video_allow_rotate = settings->bools.video_allow_rotate;
RARCH_LOG("[Environ]: SET_ROTATION: %u\n", rotation);
if (system)
system->core_requested_rotation = rotation;
if (!video_allow_rotate)
return false;
@ -4253,11 +4255,32 @@ unsigned runloop_get_video_swap_interval(
swap_interval_config;
}
unsigned int retroarch_get_rotation(void)
/*
Returns the user defined video rotation set in the video_rotation user setting
*/
unsigned int retroarch_get_video_rotation(void)
{
settings_t *settings = config_get_ptr();
unsigned video_rotation = settings->uints.video_rotation;
return video_rotation + runloop_state.system.rotation;
return settings->uints.video_rotation;
}
/*
Returns rotation requested by the core regardless of if it has been
applied with the final video rotation
*/
unsigned int retroarch_get_core_requested_rotation(void)
{
return runloop_state.system.core_requested_rotation;
}
/*
Returns final rotation including both user chosen video rotation
and core requested rotation if allowed by video_allow_rotate
*/
unsigned int retroarch_get_rotation(void)
{
return retroarch_get_video_rotation() + runloop_state.system.rotation;
}
static void retro_run_null(void) { } /* Stub function callback impl. */