mirror/RetroArch
1
0
Fork 0
mirror of https://github.com/libretro/RetroArch synced 2025-03-02 19:13:34 +00:00
Code Issues Packages Projects Releases Wiki Activity

Append Preset (#14737) (#14757)

Browse Source 
WIP version of Append and Prepend preset, Includes UI for Standard Retroarch, but not the QT UI companion

Co-authored-by: HyperspaceMadness <remimcgill@hotmail.com>
This commit is contained in:
LibretroAdmin 2022-12-22 21:36:32 +01:00 committed by GitHub
parent 05c3c0a552
commit f836328c56
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
38 changed files with 642 additions and 109 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

4
command.c
View File

@ -1452,11 +1452,11 @@ bool command_set_shader(command_t *cmd, const char *arg)
char abs_arg[PATH_MAX_LENGTH];
const char *ref_path = settings->paths.directory_video_shader;
fill_pathname_join_special(abs_arg, ref_path, arg, sizeof(abs_arg));
return apply_shader(settings, type, abs_arg, true);
return video_shader_apply_shader(settings, type, abs_arg, true);
}
}
return apply_shader(settings, type, arg, true);
return video_shader_apply_shader(settings, type, arg, true);
}
#endif

6
gfx/drivers/d3d10.c
View File

@ -1055,7 +1055,7 @@ static void *d3d10_gfx_init(const video_info_t* video,
d3d10_fake_context.get_metrics = win32_get_metrics;
video_context_driver_set(&d3d10_fake_context);
#ifdef HAVE_SLANG
const char *shader_preset = retroarch_get_shader_preset();
const char *shader_preset = video_shader_get_current_shader_preset();
enum rarch_shader_type type = video_shader_parse_type(shader_preset);
d3d10_gfx_set_shader(d3d10, type, shader_preset);
#endif
@ -1156,7 +1156,7 @@ static void d3d10_init_history(d3d10_video_t* d3d10,
* and to reduce memory fragmentation */
assert(d3d10->shader_preset);
for (i = 0; i < (unsigned)d3d10->shader_preset->history_size + 1; i++)
for (i = 0; i < (int)d3d10->shader_preset->history_size + 1; i++)
{
d3d10->frame.texture[i].desc.Width = width;
d3d10->frame.texture[i].desc.Height = height;
@ -1349,7 +1349,7 @@ static bool d3d10_gfx_frame(
{
int i;
/* Release all render targets first to avoid memory fragmentation */
for (i = 0; i < d3d10->shader_preset->passes; i++)
for (i = 0; i < (int) d3d10->shader_preset->passes; i++)
{
d3d10_release_texture(&d3d10->pass[i].rt);
d3d10_release_texture(&d3d10->pass[i].feedback);

2
gfx/drivers/d3d11.c
View File

@ -1635,7 +1635,7 @@ static void *d3d11_gfx_init(const video_info_t* video,
d3d11_fake_context.get_flags = d3d11_get_flags;
d3d11_fake_context.get_metrics = win32_get_metrics;
video_context_driver_set(&d3d11_fake_context);
const char *shader_preset = retroarch_get_shader_preset();
const char *shader_preset = video_shader_get_current_shader_preset();
enum rarch_shader_type type = video_shader_parse_type(shader_preset);
d3d11_gfx_set_shader(d3d11, type, shader_preset);
}

2
gfx/drivers/d3d12.c
View File

@ -1949,7 +1949,7 @@ static void *d3d12_gfx_init(const video_info_t* video,
d3d12_fake_context.get_flags = d3d12_get_flags;
d3d12_fake_context.get_metrics = win32_get_metrics;
video_context_driver_set(&d3d12_fake_context);
const char *shader_preset = retroarch_get_shader_preset();
const char *shader_preset = video_shader_get_current_shader_preset();
enum rarch_shader_type type = video_shader_parse_type(shader_preset);
d3d12_gfx_set_shader(d3d12, type, shader_preset);
}

8
gfx/drivers/d3d9_renderchain.h
View File

@ -182,7 +182,7 @@ static INLINE void d3d9_renderchain_destroy_passes_and_luts(
{
int i;
for (i = 0; i < chain->passes->count; i++)
for (i = 0; i < (int) chain->passes->count; i++)
{
if (chain->passes->data[i].attrib_map)
free(chain->passes->data[i].attrib_map);
@ -241,7 +241,7 @@ static INLINE void d3d9_renderchain_unbind_all(d3d9_renderchain_t *chain)
/* Have to be a bit anal about it.
* Render targets hate it when they have filters apparently.
*/
for (i = 0; i < chain->bound_tex->count; i++)
for (i = 0; i < (int) chain->bound_tex->count; i++)
{
IDirect3DDevice9_SetSamplerState(chain->dev,
chain->bound_tex->data[i], D3DSAMP_MINFILTER, D3DTEXF_POINT);
@ -251,7 +251,7 @@ static INLINE void d3d9_renderchain_unbind_all(d3d9_renderchain_t *chain)
chain->bound_tex->data[i], (IDirect3DBaseTexture9*)NULL);
}
for (i = 0; i < chain->bound_vert->count; i++)
for (i = 0; i < (int) chain->bound_vert->count; i++)
IDirect3DDevice9_SetStreamSource(chain->dev, chain->bound_vert->data[i], 0, 0, 0);
if (chain->bound_tex)
@ -369,7 +369,7 @@ static INLINE void d3d9_recompute_pass_sizes(
return;
}
for (i = 1; i < d3d->shader.passes; i++)
for (i = 1; i < (int) d3d->shader.passes; i++)
{
d3d9_convert_geometry(
&link_info,

2
gfx/drivers/d3d9cg.c
View File

@ -1621,7 +1621,7 @@ static bool d3d9_cg_init_internal(d3d9_video_t *d3d,
d3d9_cg_fake_context.get_metrics = win32_get_metrics;
video_context_driver_set(&d3d9_cg_fake_context);
{
const char *shader_preset = retroarch_get_shader_preset();
const char *shader_preset = video_shader_get_current_shader_preset();
enum rarch_shader_type type = video_shader_parse_type(shader_preset);
d3d9_cg_set_shader(d3d, type, shader_preset);

2
gfx/drivers/d3d9hlsl.c
View File

@ -1188,7 +1188,7 @@ static bool d3d9_hlsl_init_internal(d3d9_video_t *d3d,
#endif
video_context_driver_set(&d3d9_hlsl_fake_context);
{
const char *shader_preset = retroarch_get_shader_preset();
const char *shader_preset = video_shader_get_current_shader_preset();
enum rarch_shader_type type = video_shader_parse_type(shader_preset);
d3d9_hlsl_set_shader(d3d, type, shader_preset);

2
gfx/drivers/gl2.c
View File

@ -2081,7 +2081,7 @@ static bool gl2_shader_init(gl2_t *gl, const gfx_ctx_driver_t *ctx_driver,
{
video_shader_ctx_init_t init_data;
bool ret = false;
const char *shader_path = retroarch_get_shader_preset();
const char *shader_path = video_shader_get_current_shader_preset();
enum rarch_shader_type parse_type = video_shader_parse_type(shader_path);
enum rarch_shader_type type;

2
gfx/drivers/gl3.c
View File

@ -991,7 +991,7 @@ static bool gl3_init_filter_chain_preset(gl3_t *gl, const char *shader_path)
static bool gl3_init_filter_chain(gl3_t *gl)
{
const char *shader_path = retroarch_get_shader_preset();
const char *shader_path = video_shader_get_current_shader_preset();
enum rarch_shader_type type = video_shader_parse_type(shader_path);
if (string_is_empty(shader_path))

2
gfx/drivers/gx2_gfx.c
View File

@ -499,7 +499,7 @@ static void *wiiu_gfx_init(const video_info_t *video,
video_context_driver_set(&wiiu_fake_context);
shader_preset = retroarch_get_shader_preset();
shader_preset = video_shader_get_current_shader_preset();
type = video_shader_parse_type(shader_preset);
wiiu_gfx_set_shader(wiiu, type, shader_preset);
}

2
gfx/drivers/metal.m
View File

@ -176,7 +176,7 @@ static void *metal_init(
metal_fake_context.get_flags = metal_get_flags;
video_context_driver_set(&metal_fake_context);
shader_path = retroarch_get_shader_preset();
shader_path = video_shader_get_current_shader_preset();
type = video_shader_parse_type(shader_path);
metal_set_shader((__bridge void *)md, type, shader_path);

42
gfx/drivers/vulkan.c
View File

@ -215,7 +215,7 @@ static void vulkan_init_framebuffers(
{
int i;
for (i = 0; i < vk->num_swapchain_images; i++)
for (i = 0; i < (int) vk->num_swapchain_images; i++)
{
VkImageViewCreateInfo view =
{ VK_STRUCTURE_TYPE_IMAGE_VIEW_CREATE_INFO };
@ -714,7 +714,7 @@ static void vulkan_buffer_chain_free(
static void vulkan_deinit_buffers(vk_t *vk)
{
int i;
for (i = 0; i < vk->num_swapchain_images; i++)
for (i = 0; i < (int) vk->num_swapchain_images; i++)
{
vulkan_buffer_chain_free(
vk->context->device, &vk->swapchain[i].vbo);
@ -726,7 +726,7 @@ static void vulkan_deinit_buffers(vk_t *vk)
static void vulkan_deinit_descriptor_pool(vk_t *vk)
{
int i;
for (i = 0; i < vk->num_swapchain_images; i++)
for (i = 0; i < (int) vk->num_swapchain_images; i++)
vulkan_destroy_descriptor_manager(
vk->context->device,
&vk->swapchain[i].descriptor_manager);
@ -739,7 +739,7 @@ static void vulkan_init_textures(vk_t *vk)
if (!(vk->flags & VK_FLAG_HW_ENABLE))
{
int i;
for (i = 0; i < vk->num_swapchain_images; i++)
for (i = 0; i < (int) vk->num_swapchain_images; i++)
{
vk->swapchain[i].texture = vulkan_create_texture(
vk, NULL, vk->tex_w, vk->tex_h, vk->tex_fmt,
@ -777,7 +777,7 @@ static void vulkan_deinit_textures(vk_t *vk)
vkDestroySampler(vk->context->device, vk->samplers.mipmap_nearest, NULL);
vkDestroySampler(vk->context->device, vk->samplers.mipmap_linear, NULL);
for (i = 0; i < vk->num_swapchain_images; i++)
for (i = 0; i < (int) vk->num_swapchain_images; i++)
{
if (vk->swapchain[i].texture.memory != VK_NULL_HANDLE)
vulkan_destroy_texture(
@ -795,7 +795,7 @@ static void vulkan_deinit_textures(vk_t *vk)
static void vulkan_deinit_command_buffers(vk_t *vk)
{
int i;
for (i = 0; i < vk->num_swapchain_images; i++)
for (i = 0; i < (int) vk->num_swapchain_images; i++)
{
if (vk->swapchain[i].cmd)
vkFreeCommandBuffers(vk->context->device,
@ -831,7 +831,7 @@ static void vulkan_deinit_pipelines(vk_t *vk)
static void vulkan_deinit_framebuffers(vk_t *vk)
{
int i;
for (i = 0; i < vk->num_swapchain_images; i++)
for (i = 0; i < (int) vk->num_swapchain_images; i++)
{
if (vk->backbuffers[i].framebuffer)
vkDestroyFramebuffer(vk->context->device,
@ -1041,7 +1041,7 @@ 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();
const char *shader_path = video_shader_get_current_shader_preset();
enum rarch_shader_type type = video_shader_parse_type(shader_path);
if (string_is_empty(shader_path))
@ -1232,7 +1232,7 @@ static void vulkan_set_image(void *handle,
vk->hw.wait_dst_stages = stage_flags;
vk->hw.semaphores = new_semaphores;
for (i = 0; i < vk->hw.num_semaphores; i++)
for (i = 0; i < (int) vk->hw.num_semaphores; i++)
{
vk->hw.wait_dst_stages[i] = VK_PIPELINE_STAGE_FRAGMENT_SHADER_BIT;
vk->hw.semaphores[i] = semaphores[i];
@ -1533,7 +1533,7 @@ static void *vulkan_init(const video_info_t *video,
vulkan_init_samplers(vk);
vulkan_init_textures(vk);
for (i = 0; i < vk->num_swapchain_images; i++)
for (i = 0; i < (int) vk->num_swapchain_images; i++)
{
VkCommandPoolCreateInfo pool_info;
VkCommandBufferAllocateInfo info;
@ -1636,7 +1636,7 @@ static void vulkan_check_swapchain(vk_t *vk)
vulkan_init_samplers(vk);
vulkan_init_textures(vk);
for (i = 0; i < vk->num_swapchain_images; i++)
for (i = 0; i < (int) vk->num_swapchain_images; i++)
{
VkCommandPoolCreateInfo pool_info;
VkCommandBufferAllocateInfo info;
@ -2912,7 +2912,7 @@ static bool vulkan_frame(void *data, const void *frame,
&& (!(vk->flags & VK_FLAG_MENU_ENABLE)))
{
int n;
for (n = 0; n < black_frame_insertion; ++n)
for (n = 0; n < (int) black_frame_insertion; ++n)
{
vulkan_inject_black_frame(vk, video_info);
if (vk->ctx_driver->swap_buffers)
@ -2927,7 +2927,7 @@ static bool vulkan_frame(void *data, const void *frame,
{
int i;
vk->context->flags |= VK_CTX_FLAG_SWAP_INTERVAL_EMULATION_LOCK;
for (i = 1; i < vk->context->swap_interval; i++)
for (i = 1; i < (int) vk->context->swap_interval; i++)
{
if (!vulkan_frame(vk, NULL, 0, 0, frame_count, 0, msg,
video_info))
@ -3022,7 +3022,7 @@ static bool vulkan_is_mapped_swapchain_texture_ptr(const vk_t* vk,
const void* ptr)
{
int i;
for (i = 0; i < vk->num_swapchain_images; i++)
for (i = 0; i < (int) vk->num_swapchain_images; i++)
{
if (ptr == vk->swapchain[i].texture.mapped)
return true;
@ -3390,11 +3390,11 @@ static bool vulkan_read_viewport(void *data, uint8_t *buffer, bool is_idle)
switch (vk->context->swapchain_format)
{
case VK_FORMAT_B8G8R8A8_UNORM:
for (y = 0; y < vk->vp.height; y++,
for (y = 0; y < (int) vk->vp.height; y++,
src += staging->stride, buffer -= 3 * vk->vp.width)
{
int x;
for (x = 0; x < vk->vp.width; x++)
for (x = 0; x < (int) vk->vp.width; x++)
{
buffer[3 * x + 0] = src[4 * x + 0];
buffer[3 * x + 1] = src[4 * x + 1];
@ -3405,11 +3405,11 @@ static bool vulkan_read_viewport(void *data, uint8_t *buffer, bool is_idle)
case VK_FORMAT_R8G8B8A8_UNORM:
case VK_FORMAT_A8B8G8R8_UNORM_PACK32:
for (y = 0; y < vk->vp.height; y++,
for (y = 0; y < (int) vk->vp.height; y++,
src += staging->stride, buffer -= 3 * vk->vp.width)
{
int x;
for (x = 0; x < vk->vp.width; x++)
for (x = 0; x < (int) vk->vp.width; x++)
{
buffer[3 * x + 2] = src[4 * x + 0];
buffer[3 * x + 1] = src[4 * x + 1];
@ -3463,7 +3463,7 @@ static void vulkan_overlay_free(vk_t *vk)
return;
free(vk->overlay.vertex);
for (i = 0; i < vk->overlay.count; i++)
for (i = 0; i < (int) vk->overlay.count; i++)
if (vk->overlay.images[i].memory != VK_NULL_HANDLE)
vulkan_destroy_texture(
vk->context->device,
@ -3509,7 +3509,7 @@ static void vulkan_render_overlay(vk_t *vk, unsigned width,
((vk->flags & VK_FLAG_OVERLAY_FULLSCREEN) > 0),
false);
for (i = 0; i < vk->overlay.count; i++)
for (i = 0; i < (int) vk->overlay.count; i++)
{
struct vk_draw_triangles call;
struct vk_buffer_range range;
@ -3612,7 +3612,7 @@ static bool vulkan_overlay_load(void *data,
calloc(4 * num_images, sizeof(*vk->overlay.vertex))))
goto error;
for (i = 0; i < num_images; i++)
for (i = 0; i < (int) num_images; i++)
{
int j;
vk->overlay.images[i] = vulkan_create_texture(vk, NULL,

1
gfx/drivers_shader/slang_reflection.cpp
View File

@ -336,6 +336,7 @@ static bool add_active_buffer_ranges(
}
else
{
// TODO - Try to print name
RARCH_ERR("[slang]: Unknown semantic found.\n");
return false;
}

2
gfx/video_driver.c
View File

@ -1546,7 +1546,7 @@ VIDEO_DRIVER_IS_THREADED_INTERNAL(video_st);
video_driver_filter_free();
#endif
#if defined(HAVE_CG) || defined(HAVE_GLSL) || defined(HAVE_SLANG) || defined(HAVE_HLSL)
dir_free_shader(
video_shader_dir_free_shader(
(struct rarch_dir_shader_list*)&video_st->dir_shader_list,
config_get_ptr()->bools.video_shader_remember_last_dir);
#endif

233
gfx/video_shader_parse.c
View File

@ -1111,7 +1111,6 @@ static bool video_shader_check_reference_chain_for_save(
**/
static bool video_shader_write_referenced_preset(
const char *path_to_save,
const char *shader_dir,
const struct video_shader *shader)
{
unsigned i;
@ -1755,6 +1754,137 @@ static bool override_shader_values(config_file_t *override_conf,
return return_val;
}
/*
* Copies the content of the src_shader into the dst_shader
*/
static bool replace_shader_contents(struct video_shader *src_shader,
struct video_shader *dst_shader)
{
unsigned i;
/* This sets the shader to empty */
memset(dst_shader, 0, sizeof(*dst_shader));
for (i = 0; i < src_shader->passes && i <= GFX_MAX_SHADERS; i++)
{
dst_shader->pass[i] = src_shader->pass[i];
dst_shader->passes += 1;
}
for (i = 0; i < src_shader->luts; i++)
{
strlcpy(dst_shader->lut[i].id,
src_shader->lut[i].id,
sizeof(dst_shader->lut[i].id));
strlcpy(dst_shader->lut[i].path,
src_shader->lut[i].path,
sizeof(dst_shader->lut[i].path));
dst_shader->luts += 1;
}
video_shader_resolve_parameters(dst_shader);
/* Step through the parameters in the shader and see if the parameter is in either of the shaders */
for (i = 0; i < dst_shader->num_parameters; i++)
{
/* Check the original shader */
if (video_shader_parse_find_parameter( src_shader->parameters,
src_shader->num_parameters,
dst_shader->parameters[i].id))
{
dst_shader->parameters[i].current = video_shader_parse_find_parameter( src_shader->parameters,
src_shader->num_parameters,
dst_shader->parameters[i].id)->current;
}
}
return true;
}
static bool combine_shaders(struct video_shader *combined_shader,
struct video_shader *first_shader,
struct video_shader *second_shader)
{
unsigned i;
unsigned j;
for (i = 0; i < first_shader->passes && i <= GFX_MAX_SHADERS; i++)
{
combined_shader->pass[i] = first_shader->pass[i];
combined_shader->passes += 1;
}
for (i = 0;
i < second_shader->passes && first_shader->passes + i <= GFX_MAX_SHADERS;
i++)
{
combined_shader->pass[first_shader->passes + i] = second_shader->pass[i];
combined_shader->passes += 1;
}
for (i = 0; i < first_shader->luts; i++)
{
strlcpy(combined_shader->lut[i].id,
first_shader->lut[i].id,
sizeof(combined_shader->lut[i].id));
strlcpy(combined_shader->lut[i].path,
first_shader->lut[i].path,
sizeof(combined_shader->lut[i].path));
combined_shader->luts += 1;
}
for (i = 0; i < second_shader->luts; i++)
{
bool b_name_in_list = false;
for (j = 0; j < combined_shader->luts; j++)
{
if (strncmp(second_shader->lut[i].id, combined_shader->lut[j].id, 64) == 0)
{
b_name_in_list = true;
break;
}
}
if (!b_name_in_list)
{
strlcpy(combined_shader->lut[combined_shader->luts].id,
second_shader->lut[i].id,
sizeof(combined_shader->lut[combined_shader->luts].id));
strlcpy(combined_shader->lut[combined_shader->luts].path,
second_shader->lut[i].path,
sizeof(combined_shader->lut[combined_shader->luts].path));
combined_shader->luts += 1;
}
}
video_shader_resolve_parameters(combined_shader);
/* Step through the parameters in the shader and see if the parameter is in either of the shaders */
for (i = 0; i < combined_shader->num_parameters; i++)
{
/* Check the original shader */
if (video_shader_parse_find_parameter( first_shader->parameters,
first_shader->num_parameters,
combined_shader->parameters[i].id))
{
combined_shader->parameters[i].current = video_shader_parse_find_parameter( first_shader->parameters,
first_shader->num_parameters,
combined_shader->parameters[i].id)->current;
}
/* Check the shader to append */
if (video_shader_parse_find_parameter( second_shader->parameters,
second_shader->num_parameters,
combined_shader->parameters[i].id))
{
combined_shader->parameters[i].current = video_shader_parse_find_parameter( second_shader->parameters,
second_shader->num_parameters,
combined_shader->parameters[i].id)->current;
}
}
return true;
}
/**
* video_shader_write_preset:
* @param path
@ -1770,24 +1900,23 @@ static bool override_shader_values(config_file_t *override_conf,
* @return true on success, otherwise false on failure
**/
bool video_shader_write_preset(const char *path,
const char *shader_dir,
const struct video_shader *shader,
bool reference)
{
/* We need to clean up paths to be able to properly process them
* path and shader->loaded_preset_path can use '/' on
* Windows due to Qt being Qt */
char preset_dir[PATH_MAX_LENGTH];
// char preset_dir[PATH_MAX_LENGTH];
if (!shader || string_is_empty(path))
return false;
fill_pathname_join(preset_dir, shader_dir, "presets", sizeof(preset_dir));
// fill_pathname_join(preset_dir, shader_dir, "presets", sizeof(preset_dir));
/* If we should still save a referenced preset do it now */
if (reference)
{
if (video_shader_write_referenced_preset(path, shader_dir, shader))
if (video_shader_write_referenced_preset(path, shader))
return true;
RARCH_WARN("[Shaders]: Failed writing simple preset to \"%s\" "
@ -2074,7 +2203,7 @@ bool video_shader_check_for_changes(void)
return frontend_driver_check_for_path_changes(file_change_data);
}
void dir_free_shader(
void video_shader_dir_free_shader(
struct rarch_dir_shader_list *dir_list,
bool shader_remember_last_dir)
{
@ -2095,7 +2224,7 @@ void dir_free_shader(
dir_list->remember_last_preset_dir = shader_remember_last_dir;
}
static bool dir_init_shader_internal(
static bool video_shader_dir_init_shader_internal(
bool shader_remember_last_dir,
struct rarch_dir_shader_list *dir_list,
const char *shader_dir,
@ -2156,7 +2285,7 @@ static bool dir_init_shader_internal(
return true;
}
void dir_init_shader(
static void video_shader_dir_init_shader(
void *menu_driver_data_,
settings_t *settings,
struct rarch_dir_shader_list *dir_list)
@ -2178,14 +2307,14 @@ void dir_init_shader(
#endif
/* Always free existing shader list */
dir_free_shader(dir_list,
video_shader_dir_free_shader(dir_list,
video_shader_remember_last_dir);
/* Try directory of last selected shader preset */
if (shader_remember_last_dir &&
(last_shader_preset_type != RARCH_SHADER_NONE) &&
!string_is_empty(last_shader_preset_dir) &&
dir_init_shader_internal(
video_shader_dir_init_shader_internal(
video_shader_remember_last_dir,
dir_list,
last_shader_preset_dir,
@ -2195,7 +2324,7 @@ void dir_init_shader(
/* Try video shaders directory */
if (!string_is_empty(directory_video_shader) &&
dir_init_shader_internal(
video_shader_dir_init_shader_internal(
video_shader_remember_last_dir,
dir_list,
directory_video_shader, NULL, show_hidden_files))
@ -2203,7 +2332,7 @@ void dir_init_shader(
/* Try config directory */
if (!string_is_empty(directory_menu_config) &&
dir_init_shader_internal(
video_shader_dir_init_shader_internal(
video_shader_remember_last_dir,
dir_list,
directory_menu_config, NULL, show_hidden_files))
@ -2217,7 +2346,7 @@ void dir_init_shader(
path_basedir(rarch_config_directory);
if (!string_is_empty(rarch_config_directory))
dir_init_shader_internal(
video_shader_dir_init_shader_internal(
video_shader_remember_last_dir,
dir_list,
rarch_config_directory, NULL, show_hidden_files);
@ -2226,7 +2355,7 @@ void dir_init_shader(
}
}
void dir_check_shader(
void video_shader_dir_check_shader(
void *menu_driver_data_,
settings_t *settings,
struct rarch_dir_shader_list *dir_list,
@ -2257,7 +2386,7 @@ void dir_check_shader(
(last_shader_preset_type != RARCH_SHADER_NONE) &&
!string_is_equal(dir_list->directory, last_shader_preset_dir)))
{
dir_init_shader(menu_ptr, settings, dir_list);
video_shader_dir_init_shader(menu_ptr, settings, dir_list);
dir_list_initialised = true;
}
@ -2270,7 +2399,7 @@ void dir_check_shader(
* > Note: We can end up calling
* string_is_equal(dir_list->directory, last_shader_preset_dir)
* twice. This is wasteful, but we cannot safely cache
* the first result since dir_init_shader() is called
* the first result since video_shader_dir_init_shader() is called
* in-between the two invocations... */
if (video_shader_remember_last_dir &&
(last_shader_preset_type != RARCH_SHADER_NONE) &&
@ -2371,7 +2500,7 @@ void dir_check_shader(
dir_list->shader_loaded = true;
}
static bool retroarch_load_shader_preset_internal(
static bool video_shader_load_shader_preset_internal(
char *s,
size_t len,
const char *shader_directory,
@ -2415,7 +2544,7 @@ static bool retroarch_load_shader_preset_internal(
return false;
}
bool load_shader_preset(settings_t *settings, const char *core_name,
static bool video_shader_load_auto_shader_preset(settings_t *settings, const char *core_name,
char *s, size_t len)
{
const char *video_shader_directory = settings->paths.directory_video_shader;
@ -2461,28 +2590,28 @@ bool load_shader_preset(settings_t *settings, const char *core_name,
if (string_is_empty(dirs[i]))
continue;
/* Game-specific shader preset found? */
if (has_content && retroarch_load_shader_preset_internal(
if (has_content && video_shader_load_shader_preset_internal(
shader_path,
sizeof(shader_path),
dirs[i], core_name,
game_name))
goto success;
/* Folder-specific shader preset found? */
if (has_content && retroarch_load_shader_preset_internal(
if (has_content && video_shader_load_shader_preset_internal(
shader_path,
sizeof(shader_path),
dirs[i], core_name,
content_dir_name))
goto success;
/* Core-specific shader preset found? */
if (retroarch_load_shader_preset_internal(
if (video_shader_load_shader_preset_internal(
shader_path,
sizeof(shader_path),
dirs[i], core_name,
core_name))
goto success;
/* Global shader preset found? */
if (retroarch_load_shader_preset_internal(
if (video_shader_load_shader_preset_internal(
shader_path,
sizeof(shader_path),
dirs[i], NULL,
@ -2497,17 +2626,65 @@ success:
return true;
}
bool apply_shader(
bool video_shader_combine_preset_and_apply(
settings_t *settings,
enum rarch_shader_type type,
const char *preset_path, bool message)
struct video_shader *menu_shader,
const char *preset_path,
const char *temp_dir,
bool prepend,
bool message)
{
runloop_state_t *runloop_st = runloop_state_get_ptr();
const char *current_preset_path = runloop_st->runtime_shader_preset_path;
bool ret = false;
char combined_preset_path[PATH_MAX_LENGTH];
char combined_preset_name[PATH_MAX_LENGTH];
combined_preset_path[0] = '\0';
combined_preset_name[0] = '\0';
const char *preset_ext = video_shader_get_preset_extension(type);
struct video_shader *shader_to_append = (struct video_shader*) calloc(1, sizeof(*shader_to_append));
struct video_shader *combined_shader = (struct video_shader*) calloc(1, sizeof(*combined_shader));
strlcpy(combined_preset_name, "retroarch", sizeof(combined_preset_name));
strlcat(combined_preset_name, preset_ext, sizeof(combined_preset_name));
fill_pathname_join(combined_preset_path, temp_dir, combined_preset_name, sizeof(combined_preset_path));
video_shader_load_preset_into_shader(preset_path, shader_to_append);
if (prepend)
combine_shaders(combined_shader, shader_to_append, menu_shader);
else
combine_shaders(combined_shader, menu_shader, shader_to_append);
/* We save to the always changing retroarch.slangp, retroarch.glsp...
then load it so that it is similar to Apply Preset */
video_shader_write_preset(combined_preset_path, combined_shader, false);
ret = menu_shader_manager_set_preset(menu_shader, type, combined_preset_path, true);
free(shader_to_append);
free(combined_shader);
return ret;
}
/* Sets and loads the preset in the video driver */
/* Applies the preset to the menu */
bool video_shader_apply_shader(
settings_t *settings,
enum rarch_shader_type type,
const char *preset_path,
bool message)
{
char msg[256];
video_driver_state_t
*video_st = video_state_get_ptr();
video_driver_state_t *video_st = video_state_get_ptr();
runloop_state_t *runloop_st = runloop_state_get_ptr();
const char *core_name = runloop_st->system.info.library_name;
const char *preset_file = NULL;
const char* current_preset_path = runloop_st->runtime_shader_preset_path;
#ifdef HAVE_MENU
struct video_shader *shader = menu_shader_get();
#endif
@ -2597,7 +2774,7 @@ bool apply_shader(
}
/* get the name of the current shader preset */
const char *retroarch_get_shader_preset(void)
const char *video_shader_get_current_shader_preset(void)
{
settings_t *settings = config_get_ptr();
runloop_state_t *runloop_st = runloop_state_get_ptr();
@ -2637,7 +2814,7 @@ const char *retroarch_get_shader_preset(void)
{
if (auto_shaders_enable) /* sets runtime_shader_preset_path */
{
if (load_shader_preset(
if (video_shader_load_auto_shader_preset(
settings,
runloop_st->system.info.library_name,
runloop_st->runtime_shader_preset_path,

30
gfx/video_shader_parse.h
View File

@ -233,7 +233,6 @@ bool video_shader_load_preset_into_shader(const char *path, struct video_shader
* Writes a preset to disk. Can be written as a simple preset (With the #reference directive in it) or a full preset.
**/
bool video_shader_write_preset(const char *path,
const char *shader_dir,
const struct video_shader *shader,
bool reference);
@ -259,17 +258,17 @@ bool video_shader_check_for_changes(void);
const char *video_shader_type_to_str(enum rarch_shader_type type);
void dir_free_shader(
void video_shader_dir_free_shader(
struct rarch_dir_shader_list *dir_list,
bool shader_remember_last_dir);
void dir_init_shader(
void *menu_driver_data_,
settings_t *settings,
struct rarch_dir_shader_list *dir_list);
// void video_shader_dir_init_shader(
// void *menu_driver_data_,
// settings_t *settings,
// struct rarch_dir_shader_list *dir_list);
/**
* dir_check_shader:
* video_shader_dir_check_shader:
* @pressed_next : Was next shader key pressed?
* @pressed_prev : Was previous shader key pressed?
*
@ -279,7 +278,7 @@ void dir_init_shader(
*
* Will also immediately apply the shader.
**/
void dir_check_shader(
void video_shader_dir_check_shader(
void *menu_driver_data_,
settings_t *settings,
struct rarch_dir_shader_list *dir_list,
@ -287,7 +286,7 @@ void dir_check_shader(
bool pressed_prev);
/**
* load_shader_preset:
* video_shader_load_auto_shader_preset:
*
* Tries to load a supported core-, game-, folder-specific or global
* shader preset from its respective location:
@ -308,9 +307,18 @@ void dir_check_shader(
*
* Returns: false if there was an error or no action was performed.
*/
bool load_shader_preset(settings_t *settings, const char *core_name, char *s, size_t len);
static bool video_shader_load_auto_shader_preset(settings_t *settings, const char *core_name, char *s, size_t len);
bool apply_shader(
bool video_shader_combine_preset_and_apply(
settings_t *settings,
enum rarch_shader_type type,
struct video_shader *menu_shader,
const char *preset_path,
const char *temp_dir,
bool prepend,
bool message);
bool video_shader_apply_shader(
settings_t *settings,
enum rarch_shader_type type,
const char *preset_path, bool message);

8
intl/msg_hash_lbl.h
View File

@ -3772,6 +3772,14 @@ MSG_HASH(
MENU_ENUM_LABEL_VIDEO_SHADER_PRESET,
"video_shader_preset"
)
MSG_HASH(
MENU_ENUM_LABEL_VIDEO_SHADER_PRESET_PREPEND,
"video_shader_preset_prepend"
)
MSG_HASH(
MENU_ENUM_LABEL_VIDEO_SHADER_PRESET_APPEND,
"video_shader_preset_append"
)
MSG_HASH(
MENU_ENUM_LABEL_VIDEO_SHADER_PRESET_PARAMETERS,
"video_shader_preset_parameters"

16
intl/msg_hash_uk.c
View File

@ -532,11 +532,25 @@ int msg_hash_get_help_uk_enum(enum msg_hash_enums msg, char *s, size_t len)
" Load a shader preset directly. \n"
"The menu shader menu is updated accordingly. \n"
" \n"
"If the CGP uses scaling methods which are not \n"
"If the preset uses scaling methods which are nott \n"
"simple, (i.e. source scaling, same scaling \n"
"factor for X/Y), the scaling factor displayed \n"
"in the menu might not be correct.");
break;
case MENU_ENUM_LABEL_VIDEO_SHADER_PRESET_PREPEND:
snprintf(s, len,
"Prepend Shader Preset. \n"
" \n"
" Prepend a shader preset before the currently \n"
"loaded one. \n");
break;
case MENU_ENUM_LABEL_VIDEO_SHADER_PRESET_APPEND:
snprintf(s, len,
"Append Shader Preset. \n"
" \n"
" Append a shader preset after the currently \n"
"loaded one. \n");
break;
case MENU_ENUM_LABEL_VIDEO_SHADER_SCALE_PASS:
snprintf(s, len,
"Scale for this pass. \n"

8
intl/msg_hash_uk.h
View File

@ -4648,6 +4648,14 @@ MSG_HASH(
MENU_ENUM_LABEL_VALUE_VIDEO_SHADER_PRESET,
"Завантажити"
)
MSG_HASH(
MENU_ENUM_LABEL_VALUE_VIDEO_SHADER_PRESET_PREPEND,
"Append"
)
MSG_HASH(
MENU_ENUM_LABEL_VALUE_VIDEO_SHADER_PRESET_APPEND,
"Append"
)
MSG_HASH(
MENU_ENUM_LABEL_VALUE_VIDEO_SHADER_PRESET_SAVE,
"Зберегти"

16
intl/msg_hash_us.c
View File

@ -524,11 +524,25 @@ int msg_hash_get_help_us_enum(enum msg_hash_enums msg, char *s, size_t len)
" Load a shader preset directly. \n"
"The menu shader menu is updated accordingly. \n"
" \n"
"If the CGP uses scaling methods which are not \n"
"If the preset uses scaling methods which are nott \n"
"simple, (i.e. source scaling, same scaling \n"
"factor for X/Y), the scaling factor displayed \n"
"in the menu might not be correct.");
break;
case MENU_ENUM_LABEL_VIDEO_SHADER_PRESET_PREPEND:
snprintf(s, len,
"Prepend Shader Preset. \n"
" \n"
" Prepend a shader preset before the currently \n"
"loaded one. \n");
break;
case MENU_ENUM_LABEL_VIDEO_SHADER_PRESET_APPEND:
snprintf(s, len,
"Append Shader Preset. \n"
" \n"
" Append a shader preset after the currently \n"
"loaded one. \n");
break;
case MENU_ENUM_LABEL_VIDEO_SHADER_SCALE_PASS:
snprintf(s, len,
"Scale for this pass. \n"

24
intl/msg_hash_us.h
View File

@ -8160,6 +8160,22 @@ MSG_HASH(
MENU_ENUM_SUBLABEL_VIDEO_SHADER_PRESET,
"Load a shader preset. The shader pipeline will be automatically set-up."
)
MSG_HASH(
MENU_ENUM_LABEL_VALUE_VIDEO_SHADER_PRESET_PREPEND,
"Prepend"
)
MSG_HASH(
MENU_ENUM_SUBLABEL_VIDEO_SHADER_PRESET_PREPEND,
"Prepend Preset to currently loaded"
)
MSG_HASH(
MENU_ENUM_LABEL_VALUE_VIDEO_SHADER_PRESET_APPEND,
"Append"
)
MSG_HASH(
MENU_ENUM_SUBLABEL_VIDEO_SHADER_PRESET_APPEND,
"Append Preset to currently loaded"
)
MSG_HASH(
MENU_ENUM_LABEL_VALUE_VIDEO_SHADER_PRESET_SAVE,
"Save"
@ -11413,6 +11429,14 @@ MSG_HASH(
MENU_ENUM_LABEL_VIDEO_SHADER_PRESET_TWO,
"Shader Preset"
)
MSG_HASH(
MENU_ENUM_LABEL_VIDEO_SHADER_PRESET_PREPEND_TWO,
"Shader Preset"
)
MSG_HASH(
MENU_ENUM_LABEL_VIDEO_SHADER_PRESET_APPEND_TWO,
"Shader Preset"
)
MSG_HASH(
MENU_ENUM_LABEL_VALUE_BROWSE_URL_LIST,
"Browse URL"

10
menu/cbs/menu_cbs_deferred_push.c
View File

@ -136,6 +136,8 @@ GENERIC_DEFERRED_PUSH(deferred_push_browse_url_start, DISPLAYLIST_
GENERIC_DEFERRED_PUSH(deferred_push_core_list, DISPLAYLIST_CORES)
GENERIC_DEFERRED_PUSH(deferred_push_configurations, DISPLAYLIST_CONFIG_FILES)
GENERIC_DEFERRED_PUSH(deferred_push_video_shader_preset, DISPLAYLIST_SHADER_PRESET)
GENERIC_DEFERRED_PUSH(deferred_push_video_shader_preset_prepend, DISPLAYLIST_SHADER_PRESET_PREPEND)
GENERIC_DEFERRED_PUSH(deferred_push_video_shader_preset_append, DISPLAYLIST_SHADER_PRESET_APPEND)
GENERIC_DEFERRED_PUSH(deferred_push_video_shader_pass, DISPLAYLIST_SHADER_PASS)
GENERIC_DEFERRED_PUSH(deferred_push_video_filter, DISPLAYLIST_VIDEO_FILTERS)
GENERIC_DEFERRED_PUSH(deferred_push_images, DISPLAYLIST_IMAGES)
@ -850,6 +852,8 @@ static int menu_cbs_init_bind_deferred_push_compare_label(
{MENU_ENUM_LABEL_CORE_INPUT_REMAPPING_OPTIONS, deferred_push_core_input_remapping_options},
{MENU_ENUM_LABEL_DEFERRED_REMAP_FILE_MANAGER_LIST, deferred_push_remap_file_manager},
{MENU_ENUM_LABEL_VIDEO_SHADER_PRESET, deferred_push_video_shader_preset},
{MENU_ENUM_LABEL_VIDEO_SHADER_PRESET_PREPEND, deferred_push_video_shader_preset_prepend},
{MENU_ENUM_LABEL_VIDEO_SHADER_PRESET_APPEND, deferred_push_video_shader_preset_append},
{MENU_ENUM_LABEL_VIDEO_SHADER_PASS, deferred_push_video_shader_pass},
{MENU_ENUM_LABEL_VIDEO_FILTER, deferred_push_video_filter},
{MENU_ENUM_LABEL_MENU_WALLPAPER, deferred_push_images},
@ -1177,6 +1181,12 @@ static int menu_cbs_init_bind_deferred_push_compare_label(
case MENU_ENUM_LABEL_VIDEO_SHADER_PRESET:
BIND_ACTION_DEFERRED_PUSH(cbs, deferred_push_video_shader_preset);
break;
case MENU_ENUM_LABEL_VIDEO_SHADER_PRESET_PREPEND:
BIND_ACTION_DEFERRED_PUSH(cbs, deferred_push_video_shader_preset_prepend);
break;
case MENU_ENUM_LABEL_VIDEO_SHADER_PRESET_APPEND:
BIND_ACTION_DEFERRED_PUSH(cbs, deferred_push_video_shader_preset_append);
break;
case MENU_ENUM_LABEL_VIDEO_SHADER_PASS:
BIND_ACTION_DEFERRED_PUSH(cbs, deferred_push_video_shader_pass);
break;

52
menu/cbs/menu_cbs_ok.c
View File

@ -1044,6 +1044,38 @@ int generic_action_ok_displaylist_push(const char *path,
}
#endif
break;
case ACTION_OK_DL_SHADER_PRESET_PREPEND:
#if defined(HAVE_CG) || defined(HAVE_GLSL) || defined(HAVE_SLANG) || defined(HAVE_HLSL)
{
const char *shader_file_name = NULL;
filebrowser_clear_type();
info.type = type;
info.directory_ptr = idx;
info_label = label;
dl_type = DISPLAYLIST_FILE_BROWSER_SELECT_FILE;
menu_driver_get_last_shader_preset_path(&info_path, &shader_file_name);
menu_driver_set_pending_selection(shader_file_name);
}
#endif
break;
case ACTION_OK_DL_SHADER_PRESET_APPEND:
#if defined(HAVE_CG) || defined(HAVE_GLSL) || defined(HAVE_SLANG) || defined(HAVE_HLSL)
{
const char *shader_file_name = NULL;
filebrowser_clear_type();
info.type = type;
info.directory_ptr = idx;
info_label = label;
dl_type = DISPLAYLIST_FILE_BROWSER_SELECT_FILE;
menu_driver_get_last_shader_preset_path(&info_path, &shader_file_name);
menu_driver_set_pending_selection(shader_file_name);
}
#endif
break;
case ACTION_OK_DL_CONTENT_LIST:
info.type = FILE_TYPE_DIRECTORY;
info.directory_ptr = idx;
@ -2021,10 +2053,16 @@ static int generic_action_ok(const char *path,
/* Cache selected shader parent directory/file name */
menu_driver_set_last_shader_preset_path(action_path);
menu_shader_manager_set_preset(shader,
menu_driver_get_last_shader_preset_type(),
action_path,
true);
/* Check whether this a load or append action */
if (string_is_equal(menu_label, msg_hash_to_str(MENU_ENUM_LABEL_VIDEO_SHADER_PRESET_PREPEND)) ||
string_is_equal(menu_label, msg_hash_to_str(MENU_ENUM_LABEL_VIDEO_SHADER_PRESET_APPEND)))
menu_shader_manager_append_preset(shader, action_path,
string_is_equal(menu_label, msg_hash_to_str(MENU_ENUM_LABEL_VIDEO_SHADER_PRESET_PREPEND)));
else
menu_shader_manager_set_preset(shader,
menu_driver_get_last_shader_preset_type(),
action_path,
true);
}
#endif
break;
@ -2254,7 +2292,7 @@ DEFAULT_ACTION_OK_SET(action_ok_record_configfile_load, ACTION_OK_LOAD_RECO
DEFAULT_ACTION_OK_SET(action_ok_stream_configfile_load, ACTION_OK_LOAD_STREAM_CONFIGFILE, MENU_ENUM_LABEL_RECORDING_SETTINGS)
DEFAULT_ACTION_OK_SET(action_ok_remap_file_load, ACTION_OK_LOAD_REMAPPING_FILE, MENU_ENUM_LABEL_DEFERRED_REMAP_FILE_MANAGER_LIST)
#if defined(HAVE_CG) || defined(HAVE_GLSL) || defined(HAVE_SLANG) || defined(HAVE_HLSL)
DEFAULT_ACTION_OK_SET(action_ok_shader_preset_load, ACTION_OK_LOAD_PRESET , MENU_ENUM_LABEL_SHADER_OPTIONS)
DEFAULT_ACTION_OK_SET(action_ok_shader_preset_load, ACTION_OK_LOAD_PRESET, MENU_ENUM_LABEL_SHADER_OPTIONS)
DEFAULT_ACTION_OK_SET(action_ok_shader_pass_load, ACTION_OK_LOAD_SHADER_PASS, MENU_ENUM_LABEL_SHADER_OPTIONS)
#endif
DEFAULT_ACTION_OK_SET(action_ok_rgui_menu_theme_preset_load, ACTION_OK_LOAD_RGUI_MENU_THEME_PRESET, MENU_ENUM_LABEL_MENU_SETTINGS)
@ -5824,6 +5862,8 @@ DEFAULT_ACTION_OK_FUNC(action_ok_stream_configfile, ACTION_OK_DL_STREAM_CONFIGFI
DEFAULT_ACTION_OK_FUNC(action_ok_remap_file, ACTION_OK_DL_REMAP_FILE)
#if defined(HAVE_CG) || defined(HAVE_GLSL) || defined(HAVE_SLANG) || defined(HAVE_HLSL)
DEFAULT_ACTION_OK_FUNC(action_ok_shader_preset, ACTION_OK_DL_SHADER_PRESET)
DEFAULT_ACTION_OK_FUNC(action_ok_shader_preset_prepend, ACTION_OK_DL_SHADER_PRESET_PREPEND)
DEFAULT_ACTION_OK_FUNC(action_ok_shader_preset_append, ACTION_OK_DL_SHADER_PRESET_APPEND)
#endif
DEFAULT_ACTION_OK_FUNC(action_ok_push_generic_list, ACTION_OK_DL_GENERIC)
DEFAULT_ACTION_OK_FUNC(action_ok_audio_dsp_plugin, ACTION_OK_DL_AUDIO_DSP_PLUGIN)
@ -8026,6 +8066,8 @@ static int menu_cbs_init_bind_ok_compare_label(menu_file_list_cbs_t *cbs,
#if defined(HAVE_CG) || defined(HAVE_GLSL) || defined(HAVE_SLANG) || defined(HAVE_HLSL)
{MENU_ENUM_LABEL_VIDEO_SHADER_PASS, action_ok_shader_pass},
{MENU_ENUM_LABEL_VIDEO_SHADER_PRESET, action_ok_shader_preset},
{MENU_ENUM_LABEL_VIDEO_SHADER_PRESET_PREPEND, action_ok_shader_preset_prepend},
{MENU_ENUM_LABEL_VIDEO_SHADER_PRESET_APPEND, action_ok_shader_preset_append},
{MENU_ENUM_LABEL_VIDEO_SHADER_PARAMETERS, action_ok_shader_parameters},
{MENU_ENUM_LABEL_VIDEO_SHADER_PRESET_PARAMETERS, action_ok_shader_parameters},
{MENU_ENUM_LABEL_SHADER_APPLY_CHANGES, action_ok_shader_apply_changes},

40
menu/cbs/menu_cbs_start.c
View File

@ -120,6 +120,40 @@ static int action_start_shader_preset(
return 0;
}
static int action_start_shader_preset_prepend(
const char* path, const char* label,
unsigned type, size_t idx, size_t entry_idx)
{
#if defined(HAVE_CG) || defined(HAVE_GLSL) || defined(HAVE_SLANG) || defined(HAVE_HLSL)
bool refresh = false;
struct video_shader* shader = menu_shader_get();
shader->passes = 0;
menu_entries_ctl(MENU_ENTRIES_CTL_SET_REFRESH, &refresh);
menu_driver_ctl(RARCH_MENU_CTL_SET_PREVENT_POPULATE, NULL);
command_event(CMD_EVENT_SHADERS_APPLY_CHANGES, NULL);
#endif
return 0;
}
static int action_start_shader_preset_append(
const char* path, const char* label,
unsigned type, size_t idx, size_t entry_idx)
{
#if defined(HAVE_CG) || defined(HAVE_GLSL) || defined(HAVE_SLANG) || defined(HAVE_HLSL)
bool refresh = false;
struct video_shader* shader = menu_shader_get();
shader->passes = 0;
menu_entries_ctl(MENU_ENTRIES_CTL_SET_REFRESH, &refresh);
menu_driver_ctl(RARCH_MENU_CTL_SET_PREVENT_POPULATE, NULL);
command_event(CMD_EVENT_SHADERS_APPLY_CHANGES, NULL);
#endif
return 0;
}
static int action_start_video_filter_file_load(
const char *path, const char *label,
unsigned type, size_t idx, size_t entry_idx)
@ -752,6 +786,12 @@ static int menu_cbs_init_bind_start_compare_label(menu_file_list_cbs_t *cbs)
case MENU_ENUM_LABEL_VIDEO_SHADER_PRESET:
BIND_ACTION_START(cbs, action_start_shader_preset);
break;
case MENU_ENUM_LABEL_VIDEO_SHADER_PRESET_APPEND:
BIND_ACTION_START(cbs, action_start_shader_preset_append);
break;
case MENU_ENUM_LABEL_VIDEO_SHADER_PRESET_PREPEND:
BIND_ACTION_START(cbs, action_start_shader_preset_prepend);
break;
case MENU_ENUM_LABEL_REMAP_FILE_INFO:
BIND_ACTION_START(cbs, action_start_remap_file_info);
break;

8
menu/cbs/menu_cbs_sublabel.c
View File

@ -1055,6 +1055,8 @@ DEFAULT_SUBLABEL_MACRO(action_bind_sublabel_shader_watch_for_changes,
DEFAULT_SUBLABEL_MACRO(action_bind_sublabel_video_shader_remember_last_dir, MENU_ENUM_SUBLABEL_VIDEO_SHADER_REMEMBER_LAST_DIR)
DEFAULT_SUBLABEL_MACRO(action_bind_sublabel_shader_num_passes, MENU_ENUM_SUBLABEL_VIDEO_SHADER_NUM_PASSES)
DEFAULT_SUBLABEL_MACRO(action_bind_sublabel_shader_preset, MENU_ENUM_SUBLABEL_VIDEO_SHADER_PRESET)
DEFAULT_SUBLABEL_MACRO(action_bind_sublabel_shader_preset_prepend, MENU_ENUM_SUBLABEL_VIDEO_SHADER_PRESET_APPEND)
DEFAULT_SUBLABEL_MACRO(action_bind_sublabel_shader_preset_append, MENU_ENUM_SUBLABEL_VIDEO_SHADER_PRESET_APPEND)
DEFAULT_SUBLABEL_MACRO(action_bind_sublabel_shader_preset_save, MENU_ENUM_SUBLABEL_VIDEO_SHADER_PRESET_SAVE)
DEFAULT_SUBLABEL_MACRO(action_bind_sublabel_shader_preset_remove, MENU_ENUM_SUBLABEL_VIDEO_SHADER_PRESET_REMOVE)
DEFAULT_SUBLABEL_MACRO(action_bind_sublabel_shader_preset_save_reference, MENU_ENUM_SUBLABEL_VIDEO_SHADER_PRESET_SAVE_REFERENCE)
@ -2471,6 +2473,12 @@ int menu_cbs_init_bind_sublabel(menu_file_list_cbs_t *cbs,
case MENU_ENUM_LABEL_VIDEO_SHADER_PRESET:
BIND_ACTION_SUBLABEL(cbs, action_bind_sublabel_shader_preset);
break;
case MENU_ENUM_LABEL_VIDEO_SHADER_PRESET_PREPEND:
BIND_ACTION_SUBLABEL(cbs, action_bind_sublabel_shader_preset_prepend);
break;
case MENU_ENUM_LABEL_VIDEO_SHADER_PRESET_APPEND:
BIND_ACTION_SUBLABEL(cbs, action_bind_sublabel_shader_preset_append);
break;
case MENU_ENUM_LABEL_VIDEO_SHADER_NUM_PASSES:
BIND_ACTION_SUBLABEL(cbs, action_bind_sublabel_shader_num_passes);
break;

12
menu/cbs/menu_cbs_title.c
View File

@ -792,6 +792,8 @@ DEFAULT_TITLE_SEARCH_FILTER_MACRO(action_get_core_manager_steam_list, MENU
DEFAULT_TITLE_SEARCH_FILTER_MACRO(action_get_core_cheat_options_list, MENU_ENUM_LABEL_VALUE_CORE_CHEAT_OPTIONS)
DEFAULT_FILL_TITLE_SEARCH_FILTER_MACRO(action_get_title_video_shader_preset, MENU_ENUM_LABEL_VIDEO_SHADER_PRESET_TWO)
DEFAULT_FILL_TITLE_SEARCH_FILTER_MACRO(action_get_title_video_shader_preset_prepend, MENU_ENUM_LABEL_VIDEO_SHADER_PRESET_PREPEND_TWO)
DEFAULT_FILL_TITLE_SEARCH_FILTER_MACRO(action_get_title_video_shader_preset_append, MENU_ENUM_LABEL_VIDEO_SHADER_PRESET_APPEND_TWO)
DEFAULT_FILL_TITLE_SEARCH_FILTER_MACRO(action_get_title_cheat_file_load, MENU_ENUM_LABEL_VALUE_CHEAT_FILE)
DEFAULT_FILL_TITLE_SEARCH_FILTER_MACRO(action_get_title_cheat_file_load_append, MENU_ENUM_LABEL_VALUE_CHEAT_FILE_APPEND)
DEFAULT_FILL_TITLE_SEARCH_FILTER_MACRO(action_get_title_overlay, MENU_ENUM_LABEL_VALUE_OVERLAY_PRESET)
@ -1257,6 +1259,10 @@ static int menu_cbs_init_bind_title_compare_label(menu_file_list_cbs_t *cbs,
action_get_title_disk_image_append},
{MENU_ENUM_LABEL_VIDEO_SHADER_PRESET,
action_get_title_video_shader_preset},
{MENU_ENUM_LABEL_VIDEO_SHADER_PRESET_PREPEND,
action_get_title_video_shader_preset_prepend},
{MENU_ENUM_LABEL_VIDEO_SHADER_PRESET_APPEND,
action_get_title_video_shader_preset_append},
{MENU_ENUM_LABEL_CHEAT_FILE_LOAD,
action_get_title_cheat_file_load},
{MENU_ENUM_LABEL_CHEAT_FILE_LOAD_APPEND,
@ -1658,6 +1664,12 @@ static int menu_cbs_init_bind_title_compare_label(menu_file_list_cbs_t *cbs,
case MENU_ENUM_LABEL_VIDEO_SHADER_PRESET:
BIND_ACTION_GET_TITLE(cbs, action_get_title_video_shader_preset);
break;
case MENU_ENUM_LABEL_VIDEO_SHADER_PRESET_PREPEND:
BIND_ACTION_GET_TITLE(cbs, action_get_title_video_shader_preset_prepend);
break;
case MENU_ENUM_LABEL_VIDEO_SHADER_PRESET_APPEND:
BIND_ACTION_GET_TITLE(cbs, action_get_title_video_shader_preset_append);
break;
case MENU_ENUM_LABEL_CHEAT_FILE_LOAD:
BIND_ACTION_GET_TITLE(cbs, action_get_title_cheat_file_load);
break;

2
menu/drivers/materialui.c
View File

@ -10803,6 +10803,8 @@ static void materialui_list_insert(
string_is_equal(label, msg_hash_to_str(MENU_ENUM_LABEL_SHADER_APPLY_CHANGES)) ||
string_is_equal(label, msg_hash_to_str(MENU_ENUM_LABEL_CHEAT_APPLY_CHANGES)) ||
string_is_equal(label, msg_hash_to_str(MENU_ENUM_LABEL_VIDEO_SHADER_PRESET)) ||
string_is_equal(label, msg_hash_to_str(MENU_ENUM_LABEL_VIDEO_SHADER_PRESET_PREPEND)) ||
string_is_equal(label, msg_hash_to_str(MENU_ENUM_LABEL_VIDEO_SHADER_PRESET_APPEND)) ||
string_is_equal(label, msg_hash_to_str(MENU_ENUM_LABEL_NETPLAY_LOBBY_FILTERS)) ||
string_is_equal(label, msg_hash_to_str(MENU_ENUM_LABEL_NETPLAY_REFRESH_ROOMS)) ||
string_is_equal(label, msg_hash_to_str(MENU_ENUM_LABEL_NETPLAY_REFRESH_LAN)) ||

2
menu/drivers/ozone.c
View File

@ -2128,6 +2128,8 @@ static uintptr_t ozone_entries_icon_get_texture(
case MENU_ENUM_LABEL_AUTO_OVERRIDES_ENABLE:
case MENU_ENUM_LABEL_AUTO_REMAPS_ENABLE:
case MENU_ENUM_LABEL_VIDEO_SHADER_PRESET:
case MENU_ENUM_LABEL_VIDEO_SHADER_PRESET_PREPEND:
case MENU_ENUM_LABEL_VIDEO_SHADER_PRESET_APPEND:
case MENU_ENUM_LABEL_CHEAT_FILE_LOAD:
case MENU_ENUM_LABEL_CHEAT_FILE_LOAD_APPEND:
return ozone->icons_textures[OZONE_ENTRIES_ICONS_TEXTURE_LOADSTATE];

2
menu/drivers/xmb.c
View File

@ -2903,6 +2903,8 @@ static uintptr_t xmb_icon_get_id(xmb_handle_t *xmb,
case MENU_ENUM_LABEL_AUTO_OVERRIDES_ENABLE:
case MENU_ENUM_LABEL_AUTO_REMAPS_ENABLE:
case MENU_ENUM_LABEL_VIDEO_SHADER_PRESET:
case MENU_ENUM_LABEL_VIDEO_SHADER_PRESET_PREPEND:
case MENU_ENUM_LABEL_VIDEO_SHADER_PRESET_APPEND:
case MENU_ENUM_LABEL_CHEAT_FILE_LOAD:
case MENU_ENUM_LABEL_CHEAT_FILE_LOAD_APPEND:
case MENU_ENUM_LABEL_CORE_RESTORE_BACKUP_LIST:

2
menu/menu_cbs.h
View File

@ -83,6 +83,8 @@ enum
ACTION_OK_DL_MUSIC_LIST,
ACTION_OK_DL_SHADER_PARAMETERS,
ACTION_OK_DL_SHADER_PRESET,
ACTION_OK_DL_SHADER_PRESET_PREPEND,
ACTION_OK_DL_SHADER_PRESET_APPEND,
ACTION_OK_DL_SHADER_PRESET_SAVE,
ACTION_OK_DL_SHADER_PRESET_REMOVE,
ACTION_OK_DL_GENERIC,

81
menu/menu_displaylist.c
View File

@ -11894,6 +11894,20 @@ bool menu_displaylist_ctl(enum menu_displaylist_ctl_state type,
FILE_TYPE_PATH, 0, 0, NULL))
count++;
if (menu_entries_append(info->list,
msg_hash_to_str(MENU_ENUM_LABEL_VALUE_VIDEO_SHADER_PRESET_PREPEND),
msg_hash_to_str(MENU_ENUM_LABEL_VIDEO_SHADER_PRESET_PREPEND),
MENU_ENUM_LABEL_VIDEO_SHADER_PRESET_PREPEND,
FILE_TYPE_PATH, 0, 0, NULL))
count++;
if (menu_entries_append(info->list,
msg_hash_to_str(MENU_ENUM_LABEL_VALUE_VIDEO_SHADER_PRESET_APPEND),
msg_hash_to_str(MENU_ENUM_LABEL_VIDEO_SHADER_PRESET_APPEND),
MENU_ENUM_LABEL_VIDEO_SHADER_PRESET_APPEND,
FILE_TYPE_PATH, 0, 0, NULL))
count++;
if (menu_entries_append(info->list,
msg_hash_to_str(MENU_ENUM_LABEL_VALUE_VIDEO_SHADER_PRESET_SAVE),
msg_hash_to_str(MENU_ENUM_LABEL_VIDEO_SHADER_PRESET_SAVE),
@ -13740,6 +13754,7 @@ bool menu_displaylist_ctl(enum menu_displaylist_ctl_state type,
if (video_shader_is_supported(RARCH_SHADER_SLANG))
string_list_append(&str_list, "slangp", attr);
break;
case DISPLAYLIST_SHADER_PASS:
info->type_default = FILE_TYPE_SHADER;
if (video_shader_is_supported(RARCH_SHADER_CG))
@ -13762,6 +13777,72 @@ bool menu_displaylist_ctl(enum menu_displaylist_ctl_state type,
}
#endif
break;
case DISPLAYLIST_SHADER_PRESET_PREPEND:
menu_entries_ctl(MENU_ENTRIES_CTL_CLEAR, info->list);
#if defined(HAVE_CG) || defined(HAVE_GLSL) || defined(HAVE_SLANG) || defined(HAVE_HLSL)
{
struct string_list str_list = {0};
char new_exts[PATH_MAX_LENGTH];
union string_list_elem_attr attr;
attr.i = 0;
new_exts[0] = '\0';
string_list_initialize(&str_list);
filebrowser_clear_type();
info->type_default = FILE_TYPE_SHADER_PRESET;
if (video_shader_is_supported(RARCH_SHADER_CG))
string_list_append(&str_list, "cgp", attr);
if (video_shader_is_supported(RARCH_SHADER_GLSL))
string_list_append(&str_list, "glslp", attr);
if (video_shader_is_supported(RARCH_SHADER_SLANG))
string_list_append(&str_list, "slangp", attr);
string_list_join_concat(new_exts, sizeof(new_exts), &str_list, "|");
if (!string_is_empty(info->exts))
free(info->exts);
info->exts = strdup(new_exts);
string_list_deinitialize(&str_list);
use_filebrowser = true;
}
#endif
break;
case DISPLAYLIST_SHADER_PRESET_APPEND:
menu_entries_ctl(MENU_ENTRIES_CTL_CLEAR, info->list);
#if defined(HAVE_CG) || defined(HAVE_GLSL) || defined(HAVE_SLANG) || defined(HAVE_HLSL)
{
struct string_list str_list = {0};
char new_exts[PATH_MAX_LENGTH];
union string_list_elem_attr attr;
attr.i = 0;
new_exts[0] = '\0';
string_list_initialize(&str_list);
filebrowser_clear_type();
info->type_default = FILE_TYPE_SHADER_PRESET;
if (video_shader_is_supported(RARCH_SHADER_CG))
string_list_append(&str_list, "cgp", attr);
if (video_shader_is_supported(RARCH_SHADER_GLSL))
string_list_append(&str_list, "glslp", attr);
if (video_shader_is_supported(RARCH_SHADER_SLANG))
string_list_append(&str_list, "slangp", attr);
string_list_join_concat(new_exts, sizeof(new_exts), &str_list, "|");
if (!string_is_empty(info->exts))
free(info->exts);
info->exts = strdup(new_exts);
string_list_deinitialize(&str_list);
use_filebrowser = true;
}
#endif
break;
case DISPLAYLIST_IMAGES:
menu_entries_ctl(MENU_ENTRIES_CTL_CLEAR, info->list);
if ( (filebrowser_get_type() != FILEBROWSER_SELECT_FILE)

4
menu/menu_displaylist.h
View File

@ -277,7 +277,9 @@ enum menu_displaylist_ctl_state
DISPLAYLIST_CPU_PERFPOWER_LIST,
DISPLAYLIST_CPU_POLICY_LIST,
#endif
DISPLAYLIST_PENDING_CLEAR
DISPLAYLIST_PENDING_CLEAR,
DISPLAYLIST_SHADER_PRESET_PREPEND,
DISPLAYLIST_SHADER_PRESET_APPEND
};
enum filebrowser_enums

86
menu/menu_driver.c
View File

@ -3007,7 +3007,7 @@ bool menu_shader_manager_auto_preset_exists(
* SHADER_PRESET_CORE: <target dir>/<core name>/<core name>
* SHADER_PRESET_PARENT: <target dir>/<core name>/<parent>
* SHADER_PRESET_GAME: <target dir>/<core name>/<game name>
* Needs to be consistent with load_shader_preset()
* Needs to be consistent with video_shader_load_auto_shader_preset()
* Auto-shaders will be saved as a reference if possible
**/
bool menu_shader_manager_save_auto_preset(
@ -3083,6 +3083,8 @@ bool menu_driver_search_filter_enabled(const char *label, unsigned type)
string_is_equal(label, msg_hash_to_str(MENU_ENUM_LABEL_FAVORITES)) ||
/* > Shader presets/passes */
string_is_equal(label, msg_hash_to_str(MENU_ENUM_LABEL_VIDEO_SHADER_PRESET)) ||
string_is_equal(label, msg_hash_to_str(MENU_ENUM_LABEL_VIDEO_SHADER_PRESET_PREPEND)) ||
string_is_equal(label, msg_hash_to_str(MENU_ENUM_LABEL_VIDEO_SHADER_PRESET_APPEND)) ||
string_is_equal(label, msg_hash_to_str(MENU_ENUM_LABEL_VIDEO_SHADER_PASS)) ||
/* > Cheat files */
string_is_equal(label, msg_hash_to_str(MENU_ENUM_LABEL_CHEAT_FILE_LOAD)) ||
@ -3830,9 +3832,7 @@ bool menu_shader_manager_save_preset_internal(
if (path_is_absolute(fullname))
{
preset_path = fullname;
if ((ret = video_shader_write_preset(preset_path,
dir_video_shader,
shader, save_reference)))
if ((ret = video_shader_write_preset(preset_path, shader, save_reference)))
RARCH_LOG("[Shaders]: Saved shader preset to \"%s\".\n", preset_path);
else
RARCH_ERR("[Shaders]: Failed writing shader preset to \"%s\".\n", preset_path);
@ -3864,7 +3864,6 @@ bool menu_shader_manager_save_preset_internal(
preset_path = buffer;
if ((ret = video_shader_write_preset(preset_path,
dir_video_shader,
shader, save_reference)))
{
RARCH_LOG("[Shaders]: Saved shader preset to \"%s\".\n", preset_path);
@ -7277,7 +7276,7 @@ bool menu_shader_manager_init(void)
/* We get the shader preset directly from the video driver, so that
* we are in sync with it (it could fail loading an auto-shader)
* If we can't (e.g. get_current_shader is not implemented),
* we'll load retroarch_get_shader_preset() like always */
* we'll load video_shader_get_current_shader_preset() like always */
video_shader_ctx_t shader_info = {0};
video_shader_driver_get_current_shader(&shader_info);
@ -7287,7 +7286,7 @@ bool menu_shader_manager_init(void)
* have been a preset with a #reference in it to another preset */
path_shader = shader_info.data->loaded_preset_path;
else
path_shader = retroarch_get_shader_preset();
path_shader = video_shader_get_current_shader_preset();
menu_shader_manager_free();
@ -7336,21 +7335,23 @@ end:
/**
* menu_shader_manager_set_preset:
* @shader : Shader handle.
* @menu_shader : Shader handle to the menu shader.
* @type : Type of shader.
* @preset_path : Preset path to load from.
* @apply : Whether to apply the shader or just update shader information
*
* Sets shader preset.
**/
bool menu_shader_manager_set_preset(struct video_shader *shader,
enum rarch_shader_type type, const char *preset_path, bool apply)
bool menu_shader_manager_set_preset(struct video_shader *menu_shader,
enum rarch_shader_type type,
const char *preset_path,
bool apply)
{
bool refresh = false;
bool ret = false;
settings_t *settings = config_get_ptr();
if (apply && !apply_shader(settings, type, preset_path, true))
if (apply && !video_shader_apply_shader(settings, type, preset_path, true))
goto clear;
if (string_is_empty(preset_path))
@ -7363,8 +7364,8 @@ bool menu_shader_manager_set_preset(struct video_shader *shader,
* Used when a preset is directly loaded.
* No point in updating when the Preset was
* created from the menu itself. */
if ( !shader ||
!(video_shader_load_preset_into_shader(preset_path, shader)))
if ( !menu_shader ||
!(video_shader_load_preset_into_shader(preset_path, menu_shader)))
goto end;
RARCH_LOG("[Shaders]: Menu shader set to: \"%s\".\n", preset_path);
@ -7376,6 +7377,64 @@ end:
command_event(CMD_EVENT_SHADER_PRESET_LOADED, NULL);
return ret;
clear:
/* We don't want to disable shaders entirely here,
* just reset number of passes
* > Note: Disabling shaders at this point would in
* fact be dangerous, since it changes the number of
* entries in the shader options menu which can in
* turn lead to the menu selection pointer going out
* of bounds. This causes undefined behaviour/segfaults */
menu_shader_manager_clear_num_passes(menu_shader);
command_event(CMD_EVENT_SHADER_PRESET_LOADED, NULL);
return ret;
}
/**
* menu_shader_manager_append_preset:
* @shader : current shader
* @preset_path : path to the preset to append
* @dir_video_shader : temporary diretory
*
* combine current shader with a shader preset on disk
**/
bool menu_shader_manager_append_preset(struct video_shader *shader,
const char* preset_path,
const bool prepend)
{
bool refresh = false;
bool ret = false;
settings_t* settings = config_get_ptr();
const char *dir_video_shader = settings->paths.directory_video_shader;
//struct video_shader* shader = menu_shader_get();
enum rarch_shader_type type = menu_shader_manager_get_type(shader);
//if (!video_shader_apply_shader(settings, type, preset_path, true))
// goto clear;
if (string_is_empty(preset_path))
{
ret = true;
goto clear;
}
if (!video_shader_combine_preset_and_apply(settings,
type,
shader,
preset_path,
dir_video_shader,
prepend,
true))
goto clear;
RARCH_LOG("[Shaders]: Menu shader set to: \"%s\".\n", preset_path);
ret = true;
menu_entries_ctl(MENU_ENTRIES_CTL_SET_REFRESH, &refresh);
command_event(CMD_EVENT_SHADER_PRESET_LOADED, NULL);
return ret;
clear:
/* We don't want to disable shaders entirely here,
* just reset number of passes
@ -7390,6 +7449,7 @@ clear:
}
#endif
/**
* menu_iterate:
* @input : input sample for this frame

18
menu/menu_shader.h
View File

@ -52,7 +52,7 @@ bool menu_shader_manager_init(void);
/**
* menu_shader_manager_set_preset:
* @shader : Shader handle.
* @menu_shader : Shader handle to the menu shader.
* @type : Type of shader.
* @preset_path : Preset path to load from.
* @apply : Whether to apply the shader or just update shader information
@ -60,8 +60,20 @@ bool menu_shader_manager_init(void);
* Sets shader preset.
**/
bool menu_shader_manager_set_preset(
struct video_shader *shader,
enum rarch_shader_type type, const char *preset_path, bool apply);
struct video_shader *menu_shader,
enum rarch_shader_type type,
const char *preset_path,
bool apply);
/**
* menu_shader_manager_append_preset:
* @shader : current shader
* @preset_path : path to the preset to append
* @dir_video_shader : temporary diretory
*
* combine current shader with a shader preset on disk
**/
bool menu_shader_manager_append_preset(struct video_shader *shader, const char* preset_path, const bool prepend);
/**
* menu_shader_manager_save_auto_preset:

4
msg_hash.h
View File

@ -2611,8 +2611,12 @@ enum msg_hash_enums
MENU_ENUM_LABEL_VALUE_SUPPORTED_CORES,
MENU_ENUM_LABEL_VIDEO_SHADER_PASS,
MENU_ENUM_LABEL_VIDEO_SHADER_PRESET_TWO,
MENU_ENUM_LABEL_VIDEO_SHADER_PRESET_PREPEND_TWO,
MENU_ENUM_LABEL_VIDEO_SHADER_PRESET_APPEND_TWO,
MENU_LABEL(VIDEO_SHADER_PRESET),
MENU_LABEL(VIDEO_SHADER_PRESET_PREPEND),
MENU_LABEL(VIDEO_SHADER_PRESET_APPEND),
MENU_LABEL(CHEAT_FILE_LOAD),
MENU_LABEL(CHEAT_FILE_LOAD_APPEND),

8
retroarch.c
View File

@ -1524,10 +1524,10 @@ bool command_event(enum event_command cmd, void *data)
case CMD_EVENT_SHADER_NEXT:
#if defined(HAVE_CG) || defined(HAVE_GLSL) || defined(HAVE_SLANG) || defined(HAVE_HLSL)
#ifdef HAVE_MENU
dir_check_shader(menu_st->driver_data, settings,
video_shader_dir_check_shader(menu_st->driver_data, settings,
&video_st->dir_shader_list, true, false);
#else
dir_check_shader(NULL, settings,
video_shader_dir_check_shader(NULL, settings,
&video_st->dir_shader_list, true, false);
#endif
#endif
@ -1535,10 +1535,10 @@ bool command_event(enum event_command cmd, void *data)
case CMD_EVENT_SHADER_PREV:
#if defined(HAVE_CG) || defined(HAVE_GLSL) || defined(HAVE_SLANG) || defined(HAVE_HLSL)
#ifdef HAVE_MENU
dir_check_shader(menu_st->driver_data, settings,
video_shader_dir_check_shader(menu_st->driver_data, settings,
&video_st->dir_shader_list, false, true);
#else
dir_check_shader(NULL, settings,
video_shader_dir_check_shader(NULL, settings,
&video_st->dir_shader_list, false, true);
#endif
#endif

2
retroarch.h
View File

@ -96,7 +96,7 @@ void retroarch_override_setting_unset(enum rarch_override_setting enum_idx, void
bool retroarch_override_setting_is_set(enum rarch_override_setting enum_idx, void *data);
const char* retroarch_get_shader_preset(void);
const char* video_shader_get_current_shader_preset(void);
/**
* retroarch_main_init:

4
runloop.c
View File

@ -7630,9 +7630,9 @@ static enum runloop_state_enum runloop_check_state(
runloop_st->shader_delay_timer.timeout_end = 0;
{
const char *preset = retroarch_get_shader_preset();
const char *preset = video_shader_get_current_shader_preset();
enum rarch_shader_type type = video_shader_parse_type(preset);
apply_shader(settings, type, preset, false);
video_shader_apply_shader(settings, type, preset, false);
}
}
}