thirdparty/retroarch
2
0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions 1

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
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]; char abs_arg[PATH_MAX_LENGTH];
const char *ref_path = settings->paths.directory_video_shader; const char *ref_path = settings->paths.directory_video_shader;
fill_pathname_join_special(abs_arg, ref_path, arg, sizeof(abs_arg)); 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 #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; d3d10_fake_context.get_metrics = win32_get_metrics;
video_context_driver_set(&d3d10_fake_context); video_context_driver_set(&d3d10_fake_context);
#ifdef HAVE_SLANG #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); enum rarch_shader_type type = video_shader_parse_type(shader_preset);
d3d10_gfx_set_shader(d3d10, type, shader_preset); d3d10_gfx_set_shader(d3d10, type, shader_preset);
#endif #endif
@ -1156,7 +1156,7 @@ static void d3d10_init_history(d3d10_video_t* d3d10,
* and to reduce memory fragmentation */ * and to reduce memory fragmentation */
assert(d3d10->shader_preset); 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.Width = width;
d3d10->frame.texture[i].desc.Height = height; d3d10->frame.texture[i].desc.Height = height;
@ -1349,7 +1349,7 @@ static bool d3d10_gfx_frame(
{ {
int i; int i;
/* Release all render targets first to avoid memory fragmentation */ /* 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].rt);
d3d10_release_texture(&d3d10->pass[i].feedback); 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_flags = d3d11_get_flags;
d3d11_fake_context.get_metrics = win32_get_metrics; d3d11_fake_context.get_metrics = win32_get_metrics;
video_context_driver_set(&d3d11_fake_context); 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); enum rarch_shader_type type = video_shader_parse_type(shader_preset);
d3d11_gfx_set_shader(d3d11, 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_flags = d3d12_get_flags;
d3d12_fake_context.get_metrics = win32_get_metrics; d3d12_fake_context.get_metrics = win32_get_metrics;
video_context_driver_set(&d3d12_fake_context); 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); enum rarch_shader_type type = video_shader_parse_type(shader_preset);
d3d12_gfx_set_shader(d3d12, 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; 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) if (chain->passes->data[i].attrib_map)
free(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. /* Have to be a bit anal about it.
* Render targets hate it when they have filters apparently. * 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, IDirect3DDevice9_SetSamplerState(chain->dev,
chain->bound_tex->data[i], D3DSAMP_MINFILTER, D3DTEXF_POINT); 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); 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); IDirect3DDevice9_SetStreamSource(chain->dev, chain->bound_vert->data[i], 0, 0, 0);
if (chain->bound_tex) if (chain->bound_tex)
@ -369,7 +369,7 @@ static INLINE void d3d9_recompute_pass_sizes(
return; return;
} }
for (i = 1; i < d3d->shader.passes; i++) for (i = 1; i < (int) d3d->shader.passes; i++)
{ {
d3d9_convert_geometry( d3d9_convert_geometry(
&link_info, &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; d3d9_cg_fake_context.get_metrics = win32_get_metrics;
video_context_driver_set(&d3d9_cg_fake_context); 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); enum rarch_shader_type type = video_shader_parse_type(shader_preset);
d3d9_cg_set_shader(d3d, 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 #endif
video_context_driver_set(&d3d9_hlsl_fake_context); 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); enum rarch_shader_type type = video_shader_parse_type(shader_preset);
d3d9_hlsl_set_shader(d3d, 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; video_shader_ctx_init_t init_data;
bool ret = false; 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 parse_type = video_shader_parse_type(shader_path);
enum rarch_shader_type type; 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) 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); enum rarch_shader_type type = video_shader_parse_type(shader_path);
if (string_is_empty(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); 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); type = video_shader_parse_type(shader_preset);
wiiu_gfx_set_shader(wiiu, 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; metal_fake_context.get_flags = metal_get_flags;
video_context_driver_set(&metal_fake_context); 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); type = video_shader_parse_type(shader_path);
metal_set_shader((__bridge void *)md, 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; int i;
for (i = 0; i < vk->num_swapchain_images; i++) for (i = 0; i < (int) vk->num_swapchain_images; i++)
{ {
VkImageViewCreateInfo view = VkImageViewCreateInfo view =
{ VK_STRUCTURE_TYPE_IMAGE_VIEW_CREATE_INFO }; { 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) static void vulkan_deinit_buffers(vk_t *vk)
{ {
int i; 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( vulkan_buffer_chain_free(
vk->context->device, &vk->swapchain[i].vbo); 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) static void vulkan_deinit_descriptor_pool(vk_t *vk)
{ {
int i; 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( vulkan_destroy_descriptor_manager(
vk->context->device, vk->context->device,
&vk->swapchain[i].descriptor_manager); &vk->swapchain[i].descriptor_manager);
@ -739,7 +739,7 @@ static void vulkan_init_textures(vk_t *vk)
if (!(vk->flags & VK_FLAG_HW_ENABLE)) if (!(vk->flags & VK_FLAG_HW_ENABLE))
{ {
int i; 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->swapchain[i].texture = vulkan_create_texture(
vk, NULL, vk->tex_w, vk->tex_h, vk->tex_fmt, 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_nearest, NULL);
vkDestroySampler(vk->context->device, vk->samplers.mipmap_linear, 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) if (vk->swapchain[i].texture.memory != VK_NULL_HANDLE)
vulkan_destroy_texture( vulkan_destroy_texture(
@ -795,7 +795,7 @@ static void vulkan_deinit_textures(vk_t *vk)
static void vulkan_deinit_command_buffers(vk_t *vk) static void vulkan_deinit_command_buffers(vk_t *vk)
{ {
int i; 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) if (vk->swapchain[i].cmd)
vkFreeCommandBuffers(vk->context->device, vkFreeCommandBuffers(vk->context->device,
@ -831,7 +831,7 @@ static void vulkan_deinit_pipelines(vk_t *vk)
static void vulkan_deinit_framebuffers(vk_t *vk) static void vulkan_deinit_framebuffers(vk_t *vk)
{ {
int i; 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) if (vk->backbuffers[i].framebuffer)
vkDestroyFramebuffer(vk->context->device, 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) 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); enum rarch_shader_type type = video_shader_parse_type(shader_path);
if (string_is_empty(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.wait_dst_stages = stage_flags;
vk->hw.semaphores = new_semaphores; 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.wait_dst_stages[i] = VK_PIPELINE_STAGE_FRAGMENT_SHADER_BIT;
vk->hw.semaphores[i] = semaphores[i]; 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_samplers(vk);
vulkan_init_textures(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; VkCommandPoolCreateInfo pool_info;
VkCommandBufferAllocateInfo info; VkCommandBufferAllocateInfo info;
@ -1636,7 +1636,7 @@ static void vulkan_check_swapchain(vk_t *vk)
vulkan_init_samplers(vk); vulkan_init_samplers(vk);
vulkan_init_textures(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; VkCommandPoolCreateInfo pool_info;
VkCommandBufferAllocateInfo info; VkCommandBufferAllocateInfo info;
@ -2912,7 +2912,7 @@ static bool vulkan_frame(void *data, const void *frame,
&& (!(vk->flags & VK_FLAG_MENU_ENABLE))) && (!(vk->flags & VK_FLAG_MENU_ENABLE)))
{ {
int n; 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); vulkan_inject_black_frame(vk, video_info);
if (vk->ctx_driver->swap_buffers) if (vk->ctx_driver->swap_buffers)
@ -2927,7 +2927,7 @@ static bool vulkan_frame(void *data, const void *frame,
{ {
int i; int i;
vk->context->flags |= VK_CTX_FLAG_SWAP_INTERVAL_EMULATION_LOCK; 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, if (!vulkan_frame(vk, NULL, 0, 0, frame_count, 0, msg,
video_info)) video_info))
@ -3022,7 +3022,7 @@ static bool vulkan_is_mapped_swapchain_texture_ptr(const vk_t* vk,
const void* ptr) const void* ptr)
{ {
int i; 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) if (ptr == vk->swapchain[i].texture.mapped)
return true; return true;
@ -3390,11 +3390,11 @@ static bool vulkan_read_viewport(void *data, uint8_t *buffer, bool is_idle)
switch (vk->context->swapchain_format) switch (vk->context->swapchain_format)
{ {
case VK_FORMAT_B8G8R8A8_UNORM: 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) src += staging->stride, buffer -= 3 * vk->vp.width)
{ {
int x; 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 + 0] = src[4 * x + 0];
buffer[3 * x + 1] = src[4 * x + 1]; 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_R8G8B8A8_UNORM:
case VK_FORMAT_A8B8G8R8_UNORM_PACK32: 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) src += staging->stride, buffer -= 3 * vk->vp.width)
{ {
int x; 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 + 2] = src[4 * x + 0];
buffer[3 * x + 1] = src[4 * x + 1]; buffer[3 * x + 1] = src[4 * x + 1];
@ -3463,7 +3463,7 @@ static void vulkan_overlay_free(vk_t *vk)
return; return;
free(vk->overlay.vertex); 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) if (vk->overlay.images[i].memory != VK_NULL_HANDLE)
vulkan_destroy_texture( vulkan_destroy_texture(
vk->context->device, vk->context->device,
@ -3509,7 +3509,7 @@ static void vulkan_render_overlay(vk_t *vk, unsigned width,
((vk->flags & VK_FLAG_OVERLAY_FULLSCREEN) > 0), ((vk->flags & VK_FLAG_OVERLAY_FULLSCREEN) > 0),
false); 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_draw_triangles call;
struct vk_buffer_range range; struct vk_buffer_range range;
@ -3612,7 +3612,7 @@ static bool vulkan_overlay_load(void *data,
calloc(4 * num_images, sizeof(*vk->overlay.vertex)))) calloc(4 * num_images, sizeof(*vk->overlay.vertex))))
goto error; goto error;
for (i = 0; i < num_images; i++) for (i = 0; i < (int) num_images; i++)
{ {
int j; int j;
vk->overlay.images[i] = vulkan_create_texture(vk, NULL, 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 else
{ {
// TODO - Try to print name
RARCH_ERR("[slang]: Unknown semantic found.\n"); RARCH_ERR("[slang]: Unknown semantic found.\n");
return false; return false;
} }

2
gfx/video_driver.c
View file

@ -1546,7 +1546,7 @@ VIDEO_DRIVER_IS_THREADED_INTERNAL(video_st);
video_driver_filter_free(); video_driver_filter_free();
#endif #endif
#if defined(HAVE_CG) || defined(HAVE_GLSL) || defined(HAVE_SLANG) || defined(HAVE_HLSL) #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, (struct rarch_dir_shader_list*)&video_st->dir_shader_list,
config_get_ptr()->bools.video_shader_remember_last_dir); config_get_ptr()->bools.video_shader_remember_last_dir);
#endif #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( static bool video_shader_write_referenced_preset(
const char *path_to_save, const char *path_to_save,
const char *shader_dir,
const struct video_shader *shader) const struct video_shader *shader)
{ {
unsigned i; unsigned i;
@ -1755,6 +1754,137 @@ static bool override_shader_values(config_file_t *override_conf,
return return_val; 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: * video_shader_write_preset:
* @param path * @param path
@ -1770,24 +1900,23 @@ static bool override_shader_values(config_file_t *override_conf,
* @return true on success, otherwise false on failure * @return true on success, otherwise false on failure
**/ **/
bool video_shader_write_preset(const char *path, bool video_shader_write_preset(const char *path,
const char *shader_dir,
const struct video_shader *shader, const struct video_shader *shader,
bool reference) bool reference)
{ {
/* We need to clean up paths to be able to properly process them /* We need to clean up paths to be able to properly process them
* path and shader->loaded_preset_path can use '/' on * path and shader->loaded_preset_path can use '/' on
* Windows due to Qt being Qt */ * Windows due to Qt being Qt */
char preset_dir[PATH_MAX_LENGTH]; // char preset_dir[PATH_MAX_LENGTH];
if (!shader || string_is_empty(path)) if (!shader || string_is_empty(path))
return false; 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 we should still save a referenced preset do it now */
if (reference) if (reference)
{ {
if (video_shader_write_referenced_preset(path, shader_dir, shader)) if (video_shader_write_referenced_preset(path, shader))
return true; return true;
RARCH_WARN("[Shaders]: Failed writing simple preset to \"%s\" " 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); 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, struct rarch_dir_shader_list *dir_list,
bool shader_remember_last_dir) bool shader_remember_last_dir)
{ {
@ -2095,7 +2224,7 @@ void dir_free_shader(
dir_list->remember_last_preset_dir = shader_remember_last_dir; 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, bool shader_remember_last_dir,
struct rarch_dir_shader_list *dir_list, struct rarch_dir_shader_list *dir_list,
const char *shader_dir, const char *shader_dir,
@ -2156,7 +2285,7 @@ static bool dir_init_shader_internal(
return true; return true;
} }
void dir_init_shader( static void video_shader_dir_init_shader(
void *menu_driver_data_, void *menu_driver_data_,
settings_t *settings, settings_t *settings,
struct rarch_dir_shader_list *dir_list) struct rarch_dir_shader_list *dir_list)
@ -2178,14 +2307,14 @@ void dir_init_shader(
#endif #endif
/* Always free existing shader list */ /* Always free existing shader list */
dir_free_shader(dir_list, video_shader_dir_free_shader(dir_list,
video_shader_remember_last_dir); video_shader_remember_last_dir);
/* Try directory of last selected shader preset */ /* Try directory of last selected shader preset */
if (shader_remember_last_dir && if (shader_remember_last_dir &&
(last_shader_preset_type != RARCH_SHADER_NONE) && (last_shader_preset_type != RARCH_SHADER_NONE) &&
!string_is_empty(last_shader_preset_dir) && !string_is_empty(last_shader_preset_dir) &&
dir_init_shader_internal( video_shader_dir_init_shader_internal(
video_shader_remember_last_dir, video_shader_remember_last_dir,
dir_list, dir_list,
last_shader_preset_dir, last_shader_preset_dir,
@ -2195,7 +2324,7 @@ void dir_init_shader(
/* Try video shaders directory */ /* Try video shaders directory */
if (!string_is_empty(directory_video_shader) && if (!string_is_empty(directory_video_shader) &&
dir_init_shader_internal( video_shader_dir_init_shader_internal(
video_shader_remember_last_dir, video_shader_remember_last_dir,
dir_list, dir_list,
directory_video_shader, NULL, show_hidden_files)) directory_video_shader, NULL, show_hidden_files))
@ -2203,7 +2332,7 @@ void dir_init_shader(
/* Try config directory */ /* Try config directory */
if (!string_is_empty(directory_menu_config) && if (!string_is_empty(directory_menu_config) &&
dir_init_shader_internal( video_shader_dir_init_shader_internal(
video_shader_remember_last_dir, video_shader_remember_last_dir,
dir_list, dir_list,
directory_menu_config, NULL, show_hidden_files)) directory_menu_config, NULL, show_hidden_files))
@ -2217,7 +2346,7 @@ void dir_init_shader(
path_basedir(rarch_config_directory); path_basedir(rarch_config_directory);
if (!string_is_empty(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, video_shader_remember_last_dir,
dir_list, dir_list,
rarch_config_directory, NULL, show_hidden_files); 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_, void *menu_driver_data_,
settings_t *settings, settings_t *settings,
struct rarch_dir_shader_list *dir_list, struct rarch_dir_shader_list *dir_list,
@ -2257,7 +2386,7 @@ void dir_check_shader(
(last_shader_preset_type != RARCH_SHADER_NONE) && (last_shader_preset_type != RARCH_SHADER_NONE) &&
!string_is_equal(dir_list->directory, last_shader_preset_dir))) !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; dir_list_initialised = true;
} }
@ -2270,7 +2399,7 @@ void dir_check_shader(
* > Note: We can end up calling * > Note: We can end up calling
* string_is_equal(dir_list->directory, last_shader_preset_dir) * string_is_equal(dir_list->directory, last_shader_preset_dir)
* twice. This is wasteful, but we cannot safely cache * 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... */ * in-between the two invocations... */
if (video_shader_remember_last_dir && if (video_shader_remember_last_dir &&
(last_shader_preset_type != RARCH_SHADER_NONE) && (last_shader_preset_type != RARCH_SHADER_NONE) &&
@ -2371,7 +2500,7 @@ void dir_check_shader(
dir_list->shader_loaded = true; dir_list->shader_loaded = true;
} }
static bool retroarch_load_shader_preset_internal( static bool video_shader_load_shader_preset_internal(
char *s, char *s,
size_t len, size_t len,
const char *shader_directory, const char *shader_directory,
@ -2415,7 +2544,7 @@ static bool retroarch_load_shader_preset_internal(
return false; 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) char *s, size_t len)
{ {
const char *video_shader_directory = settings->paths.directory_video_shader; 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])) if (string_is_empty(dirs[i]))
continue; continue;
/* Game-specific shader preset found? */ /* Game-specific shader preset found? */
if (has_content && retroarch_load_shader_preset_internal( if (has_content && video_shader_load_shader_preset_internal(
shader_path, shader_path,
sizeof(shader_path), sizeof(shader_path),
dirs[i], core_name, dirs[i], core_name,
game_name)) game_name))
goto success; goto success;
/* Folder-specific shader preset found? */ /* Folder-specific shader preset found? */
if (has_content && retroarch_load_shader_preset_internal( if (has_content && video_shader_load_shader_preset_internal(
shader_path, shader_path,
sizeof(shader_path), sizeof(shader_path),
dirs[i], core_name, dirs[i], core_name,
content_dir_name)) content_dir_name))
goto success; goto success;
/* Core-specific shader preset found? */ /* Core-specific shader preset found? */
if (retroarch_load_shader_preset_internal( if (video_shader_load_shader_preset_internal(
shader_path, shader_path,
sizeof(shader_path), sizeof(shader_path),
dirs[i], core_name, dirs[i], core_name,
core_name)) core_name))
goto success; goto success;
/* Global shader preset found? */ /* Global shader preset found? */
if (retroarch_load_shader_preset_internal( if (video_shader_load_shader_preset_internal(
shader_path, shader_path,
sizeof(shader_path), sizeof(shader_path),
dirs[i], NULL, dirs[i], NULL,
@ -2497,17 +2626,65 @@ success:
return true; return true;
} }
bool apply_shader( bool video_shader_combine_preset_and_apply(
settings_t *settings, settings_t *settings,
enum rarch_shader_type type, 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]; char msg[256];
video_driver_state_t video_driver_state_t *video_st = video_state_get_ptr();
*video_st = video_state_get_ptr();
runloop_state_t *runloop_st = runloop_state_get_ptr(); runloop_state_t *runloop_st = runloop_state_get_ptr();
const char *core_name = runloop_st->system.info.library_name; const char *core_name = runloop_st->system.info.library_name;
const char *preset_file = NULL; const char *preset_file = NULL;
const char* current_preset_path = runloop_st->runtime_shader_preset_path;
#ifdef HAVE_MENU #ifdef HAVE_MENU
struct video_shader *shader = menu_shader_get(); struct video_shader *shader = menu_shader_get();
#endif #endif
@ -2597,7 +2774,7 @@ bool apply_shader(
} }
/* get the name of the current shader preset */ /* 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(); settings_t *settings = config_get_ptr();
runloop_state_t *runloop_st = runloop_state_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 (auto_shaders_enable) /* sets runtime_shader_preset_path */
{ {
if (load_shader_preset( if (video_shader_load_auto_shader_preset(
settings, settings,
runloop_st->system.info.library_name, runloop_st->system.info.library_name,
runloop_st->runtime_shader_preset_path, 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. * 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, bool video_shader_write_preset(const char *path,
const char *shader_dir,
const struct video_shader *shader, const struct video_shader *shader,
bool reference); 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); 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, struct rarch_dir_shader_list *dir_list,
bool shader_remember_last_dir); bool shader_remember_last_dir);
void dir_init_shader( // void video_shader_dir_init_shader(
void *menu_driver_data_, // void *menu_driver_data_,
settings_t *settings, // settings_t *settings,
struct rarch_dir_shader_list *dir_list); // struct rarch_dir_shader_list *dir_list);
/** /**
* dir_check_shader: * video_shader_dir_check_shader:
* @pressed_next : Was next shader key pressed? * @pressed_next : Was next shader key pressed?
* @pressed_prev : Was previous shader key pressed? * @pressed_prev : Was previous shader key pressed?
* *
@ -279,7 +278,7 @@ void dir_init_shader(
* *
* Will also immediately apply the shader. * Will also immediately apply the shader.
**/ **/
void dir_check_shader( void video_shader_dir_check_shader(
void *menu_driver_data_, void *menu_driver_data_,
settings_t *settings, settings_t *settings,
struct rarch_dir_shader_list *dir_list, struct rarch_dir_shader_list *dir_list,
@ -287,7 +286,7 @@ void dir_check_shader(
bool pressed_prev); bool pressed_prev);
/** /**
* load_shader_preset: * video_shader_load_auto_shader_preset:
* *
* Tries to load a supported core-, game-, folder-specific or global * Tries to load a supported core-, game-, folder-specific or global
* shader preset from its respective location: * 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. * 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, settings_t *settings,
enum rarch_shader_type type, enum rarch_shader_type type,
const char *preset_path, bool message); 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, MENU_ENUM_LABEL_VIDEO_SHADER_PRESET,
"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( MSG_HASH(
MENU_ENUM_LABEL_VIDEO_SHADER_PRESET_PARAMETERS, MENU_ENUM_LABEL_VIDEO_SHADER_PRESET_PARAMETERS,
"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" " Load a shader preset directly. \n"
"The menu shader menu is updated accordingly. \n" "The menu shader menu is updated accordingly. \n"
" \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" "simple, (i.e. source scaling, same scaling \n"
"factor for X/Y), the scaling factor displayed \n" "factor for X/Y), the scaling factor displayed \n"
"in the menu might not be correct."); "in the menu might not be correct.");
break; 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: case MENU_ENUM_LABEL_VIDEO_SHADER_SCALE_PASS:
snprintf(s, len, snprintf(s, len,
"Scale for this pass. \n" "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, 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( MSG_HASH(
MENU_ENUM_LABEL_VALUE_VIDEO_SHADER_PRESET_SAVE, 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" " Load a shader preset directly. \n"
"The menu shader menu is updated accordingly. \n" "The menu shader menu is updated accordingly. \n"
" \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" "simple, (i.e. source scaling, same scaling \n"
"factor for X/Y), the scaling factor displayed \n" "factor for X/Y), the scaling factor displayed \n"
"in the menu might not be correct."); "in the menu might not be correct.");
break; 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: case MENU_ENUM_LABEL_VIDEO_SHADER_SCALE_PASS:
snprintf(s, len, snprintf(s, len,
"Scale for this pass. \n" "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, MENU_ENUM_SUBLABEL_VIDEO_SHADER_PRESET,
"Load a shader preset. The shader pipeline will be automatically set-up." "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( MSG_HASH(
MENU_ENUM_LABEL_VALUE_VIDEO_SHADER_PRESET_SAVE, MENU_ENUM_LABEL_VALUE_VIDEO_SHADER_PRESET_SAVE,
"Save" "Save"
@ -11413,6 +11429,14 @@ MSG_HASH(
MENU_ENUM_LABEL_VIDEO_SHADER_PRESET_TWO, MENU_ENUM_LABEL_VIDEO_SHADER_PRESET_TWO,
"Shader Preset" "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( MSG_HASH(
MENU_ENUM_LABEL_VALUE_BROWSE_URL_LIST, MENU_ENUM_LABEL_VALUE_BROWSE_URL_LIST,
"Browse URL" "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_core_list, DISPLAYLIST_CORES)
GENERIC_DEFERRED_PUSH(deferred_push_configurations, DISPLAYLIST_CONFIG_FILES) 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, 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_shader_pass, DISPLAYLIST_SHADER_PASS)
GENERIC_DEFERRED_PUSH(deferred_push_video_filter, DISPLAYLIST_VIDEO_FILTERS) GENERIC_DEFERRED_PUSH(deferred_push_video_filter, DISPLAYLIST_VIDEO_FILTERS)
GENERIC_DEFERRED_PUSH(deferred_push_images, DISPLAYLIST_IMAGES) 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_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_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, 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_SHADER_PASS, deferred_push_video_shader_pass},
{MENU_ENUM_LABEL_VIDEO_FILTER, deferred_push_video_filter}, {MENU_ENUM_LABEL_VIDEO_FILTER, deferred_push_video_filter},
{MENU_ENUM_LABEL_MENU_WALLPAPER, deferred_push_images}, {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: case MENU_ENUM_LABEL_VIDEO_SHADER_PRESET:
BIND_ACTION_DEFERRED_PUSH(cbs, deferred_push_video_shader_preset); BIND_ACTION_DEFERRED_PUSH(cbs, deferred_push_video_shader_preset);
break; 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: case MENU_ENUM_LABEL_VIDEO_SHADER_PASS:
BIND_ACTION_DEFERRED_PUSH(cbs, deferred_push_video_shader_pass); BIND_ACTION_DEFERRED_PUSH(cbs, deferred_push_video_shader_pass);
break; break;

44
menu/cbs/menu_cbs_ok.c
View file

@ -1044,6 +1044,38 @@ int generic_action_ok_displaylist_push(const char *path,
} }
#endif #endif
break; 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: case ACTION_OK_DL_CONTENT_LIST:
info.type = FILE_TYPE_DIRECTORY; info.type = FILE_TYPE_DIRECTORY;
info.directory_ptr = idx; info.directory_ptr = idx;
@ -2021,6 +2053,12 @@ static int generic_action_ok(const char *path,
/* Cache selected shader parent directory/file name */ /* Cache selected shader parent directory/file name */
menu_driver_set_last_shader_preset_path(action_path); menu_driver_set_last_shader_preset_path(action_path);
/* 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_shader_manager_set_preset(shader,
menu_driver_get_last_shader_preset_type(), menu_driver_get_last_shader_preset_type(),
action_path, action_path,
@ -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_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) 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) #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) DEFAULT_ACTION_OK_SET(action_ok_shader_pass_load, ACTION_OK_LOAD_SHADER_PASS, MENU_ENUM_LABEL_SHADER_OPTIONS)
#endif #endif
DEFAULT_ACTION_OK_SET(action_ok_rgui_menu_theme_preset_load, ACTION_OK_LOAD_RGUI_MENU_THEME_PRESET, MENU_ENUM_LABEL_MENU_SETTINGS) 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) 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) #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, 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 #endif
DEFAULT_ACTION_OK_FUNC(action_ok_push_generic_list, ACTION_OK_DL_GENERIC) 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) 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) #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_PASS, action_ok_shader_pass},
{MENU_ENUM_LABEL_VIDEO_SHADER_PRESET, action_ok_shader_preset}, {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_PARAMETERS, action_ok_shader_parameters},
{MENU_ENUM_LABEL_VIDEO_SHADER_PRESET_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}, {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; 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( static int action_start_video_filter_file_load(
const char *path, const char *label, const char *path, const char *label,
unsigned type, size_t idx, size_t entry_idx) 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: case MENU_ENUM_LABEL_VIDEO_SHADER_PRESET:
BIND_ACTION_START(cbs, action_start_shader_preset); BIND_ACTION_START(cbs, action_start_shader_preset);
break; 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: case MENU_ENUM_LABEL_REMAP_FILE_INFO:
BIND_ACTION_START(cbs, action_start_remap_file_info); BIND_ACTION_START(cbs, action_start_remap_file_info);
break; 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_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_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, 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_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_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) 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: case MENU_ENUM_LABEL_VIDEO_SHADER_PRESET:
BIND_ACTION_SUBLABEL(cbs, action_bind_sublabel_shader_preset); BIND_ACTION_SUBLABEL(cbs, action_bind_sublabel_shader_preset);
break; 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: case MENU_ENUM_LABEL_VIDEO_SHADER_NUM_PASSES:
BIND_ACTION_SUBLABEL(cbs, action_bind_sublabel_shader_num_passes); BIND_ACTION_SUBLABEL(cbs, action_bind_sublabel_shader_num_passes);
break; 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_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, 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, 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_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) 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}, action_get_title_disk_image_append},
{MENU_ENUM_LABEL_VIDEO_SHADER_PRESET, {MENU_ENUM_LABEL_VIDEO_SHADER_PRESET,
action_get_title_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, {MENU_ENUM_LABEL_CHEAT_FILE_LOAD,
action_get_title_cheat_file_load}, action_get_title_cheat_file_load},
{MENU_ENUM_LABEL_CHEAT_FILE_LOAD_APPEND, {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: case MENU_ENUM_LABEL_VIDEO_SHADER_PRESET:
BIND_ACTION_GET_TITLE(cbs, action_get_title_video_shader_preset); BIND_ACTION_GET_TITLE(cbs, action_get_title_video_shader_preset);
break; 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: case MENU_ENUM_LABEL_CHEAT_FILE_LOAD:
BIND_ACTION_GET_TITLE(cbs, action_get_title_cheat_file_load); BIND_ACTION_GET_TITLE(cbs, action_get_title_cheat_file_load);
break; 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_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_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)) ||
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_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_ROOMS)) ||
string_is_equal(label, msg_hash_to_str(MENU_ENUM_LABEL_NETPLAY_REFRESH_LAN)) || 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_OVERRIDES_ENABLE:
case MENU_ENUM_LABEL_AUTO_REMAPS_ENABLE: case MENU_ENUM_LABEL_AUTO_REMAPS_ENABLE:
case MENU_ENUM_LABEL_VIDEO_SHADER_PRESET: 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:
case MENU_ENUM_LABEL_CHEAT_FILE_LOAD_APPEND: case MENU_ENUM_LABEL_CHEAT_FILE_LOAD_APPEND:
return ozone->icons_textures[OZONE_ENTRIES_ICONS_TEXTURE_LOADSTATE]; 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_OVERRIDES_ENABLE:
case MENU_ENUM_LABEL_AUTO_REMAPS_ENABLE: case MENU_ENUM_LABEL_AUTO_REMAPS_ENABLE:
case MENU_ENUM_LABEL_VIDEO_SHADER_PRESET: 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:
case MENU_ENUM_LABEL_CHEAT_FILE_LOAD_APPEND: case MENU_ENUM_LABEL_CHEAT_FILE_LOAD_APPEND:
case MENU_ENUM_LABEL_CORE_RESTORE_BACKUP_LIST: 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_MUSIC_LIST,
ACTION_OK_DL_SHADER_PARAMETERS, ACTION_OK_DL_SHADER_PARAMETERS,
ACTION_OK_DL_SHADER_PRESET, 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_SAVE,
ACTION_OK_DL_SHADER_PRESET_REMOVE, ACTION_OK_DL_SHADER_PRESET_REMOVE,
ACTION_OK_DL_GENERIC, 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)) FILE_TYPE_PATH, 0, 0, NULL))
count++; 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, 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_VALUE_VIDEO_SHADER_PRESET_SAVE),
msg_hash_to_str(MENU_ENUM_LABEL_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)) if (video_shader_is_supported(RARCH_SHADER_SLANG))
string_list_append(&str_list, "slangp", attr); string_list_append(&str_list, "slangp", attr);
break; break;
case DISPLAYLIST_SHADER_PASS: case DISPLAYLIST_SHADER_PASS:
info->type_default = FILE_TYPE_SHADER; info->type_default = FILE_TYPE_SHADER;
if (video_shader_is_supported(RARCH_SHADER_CG)) if (video_shader_is_supported(RARCH_SHADER_CG))
@ -13762,6 +13777,72 @@ bool menu_displaylist_ctl(enum menu_displaylist_ctl_state type,
} }
#endif #endif
break; 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: case DISPLAYLIST_IMAGES:
menu_entries_ctl(MENU_ENTRIES_CTL_CLEAR, info->list); menu_entries_ctl(MENU_ENTRIES_CTL_CLEAR, info->list);
if ( (filebrowser_get_type() != FILEBROWSER_SELECT_FILE) 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_PERFPOWER_LIST,
DISPLAYLIST_CPU_POLICY_LIST, DISPLAYLIST_CPU_POLICY_LIST,
#endif #endif
DISPLAYLIST_PENDING_CLEAR DISPLAYLIST_PENDING_CLEAR,
DISPLAYLIST_SHADER_PRESET_PREPEND,
DISPLAYLIST_SHADER_PRESET_APPEND
}; };
enum filebrowser_enums 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_CORE: <target dir>/<core name>/<core name>
* SHADER_PRESET_PARENT: <target dir>/<core name>/<parent> * SHADER_PRESET_PARENT: <target dir>/<core name>/<parent>
* SHADER_PRESET_GAME: <target dir>/<core name>/<game name> * 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 * Auto-shaders will be saved as a reference if possible
**/ **/
bool menu_shader_manager_save_auto_preset( 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)) || string_is_equal(label, msg_hash_to_str(MENU_ENUM_LABEL_FAVORITES)) ||
/* > Shader presets/passes */ /* > 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)) ||
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)) || string_is_equal(label, msg_hash_to_str(MENU_ENUM_LABEL_VIDEO_SHADER_PASS)) ||
/* > Cheat files */ /* > Cheat files */
string_is_equal(label, msg_hash_to_str(MENU_ENUM_LABEL_CHEAT_FILE_LOAD)) || 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)) if (path_is_absolute(fullname))
{ {
preset_path = fullname; preset_path = fullname;
if ((ret = video_shader_write_preset(preset_path, if ((ret = video_shader_write_preset(preset_path, shader, save_reference)))
dir_video_shader,
shader, save_reference)))
RARCH_LOG("[Shaders]: Saved shader preset to \"%s\".\n", preset_path); RARCH_LOG("[Shaders]: Saved shader preset to \"%s\".\n", preset_path);
else else
RARCH_ERR("[Shaders]: Failed writing shader preset to \"%s\".\n", preset_path); 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; preset_path = buffer;
if ((ret = video_shader_write_preset(preset_path, if ((ret = video_shader_write_preset(preset_path,
dir_video_shader,
shader, save_reference))) shader, save_reference)))
{ {
RARCH_LOG("[Shaders]: Saved shader preset to \"%s\".\n", preset_path); 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 get the shader preset directly from the video driver, so that
* we are in sync with it (it could fail loading an auto-shader) * 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), * 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_ctx_t shader_info = {0};
video_shader_driver_get_current_shader(&shader_info); 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 */ * have been a preset with a #reference in it to another preset */
path_shader = shader_info.data->loaded_preset_path; path_shader = shader_info.data->loaded_preset_path;
else else
path_shader = retroarch_get_shader_preset(); path_shader = video_shader_get_current_shader_preset();
menu_shader_manager_free(); menu_shader_manager_free();
@ -7336,21 +7335,23 @@ end:
/** /**
* menu_shader_manager_set_preset: * menu_shader_manager_set_preset:
* @shader : Shader handle. * @menu_shader : Shader handle to the menu shader.
* @type : Type of shader. * @type : Type of shader.
* @preset_path : Preset path to load from. * @preset_path : Preset path to load from.
* @apply : Whether to apply the shader or just update shader information * @apply : Whether to apply the shader or just update shader information
* *
* Sets shader preset. * Sets shader preset.
**/ **/
bool menu_shader_manager_set_preset(struct video_shader *shader, bool menu_shader_manager_set_preset(struct video_shader *menu_shader,
enum rarch_shader_type type, const char *preset_path, bool apply) enum rarch_shader_type type,
const char *preset_path,
bool apply)
{ {
bool refresh = false; bool refresh = false;
bool ret = false; bool ret = false;
settings_t *settings = config_get_ptr(); 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; goto clear;
if (string_is_empty(preset_path)) 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. * Used when a preset is directly loaded.
* No point in updating when the Preset was * No point in updating when the Preset was
* created from the menu itself. */ * created from the menu itself. */
if ( !shader || if ( !menu_shader ||
!(video_shader_load_preset_into_shader(preset_path, shader))) !(video_shader_load_preset_into_shader(preset_path, menu_shader)))
goto end; goto end;
RARCH_LOG("[Shaders]: Menu shader set to: \"%s\".\n", preset_path); RARCH_LOG("[Shaders]: Menu shader set to: \"%s\".\n", preset_path);
@ -7376,6 +7377,64 @@ end:
command_event(CMD_EVENT_SHADER_PRESET_LOADED, NULL); command_event(CMD_EVENT_SHADER_PRESET_LOADED, NULL);
return ret; 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: clear:
/* We don't want to disable shaders entirely here, /* We don't want to disable shaders entirely here,
* just reset number of passes * just reset number of passes
@ -7390,6 +7449,7 @@ clear:
} }
#endif #endif
/** /**
* menu_iterate: * menu_iterate:
* @input : input sample for this frame * @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: * menu_shader_manager_set_preset:
* @shader : Shader handle. * @menu_shader : Shader handle to the menu shader.
* @type : Type of shader. * @type : Type of shader.
* @preset_path : Preset path to load from. * @preset_path : Preset path to load from.
* @apply : Whether to apply the shader or just update shader information * @apply : Whether to apply the shader or just update shader information
@ -60,8 +60,20 @@ bool menu_shader_manager_init(void);
* Sets shader preset. * Sets shader preset.
**/ **/
bool menu_shader_manager_set_preset( bool menu_shader_manager_set_preset(
struct video_shader *shader, struct video_shader *menu_shader,
enum rarch_shader_type type, const char *preset_path, bool apply); 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: * 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_VALUE_SUPPORTED_CORES,
MENU_ENUM_LABEL_VIDEO_SHADER_PASS, MENU_ENUM_LABEL_VIDEO_SHADER_PASS,
MENU_ENUM_LABEL_VIDEO_SHADER_PRESET_TWO, 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),
MENU_LABEL(VIDEO_SHADER_PRESET_PREPEND),
MENU_LABEL(VIDEO_SHADER_PRESET_APPEND),
MENU_LABEL(CHEAT_FILE_LOAD), MENU_LABEL(CHEAT_FILE_LOAD),
MENU_LABEL(CHEAT_FILE_LOAD_APPEND), 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: case CMD_EVENT_SHADER_NEXT:
#if defined(HAVE_CG) || defined(HAVE_GLSL) || defined(HAVE_SLANG) || defined(HAVE_HLSL) #if defined(HAVE_CG) || defined(HAVE_GLSL) || defined(HAVE_SLANG) || defined(HAVE_HLSL)
#ifdef HAVE_MENU #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); &video_st->dir_shader_list, true, false);
#else #else
dir_check_shader(NULL, settings, video_shader_dir_check_shader(NULL, settings,
&video_st->dir_shader_list, true, false); &video_st->dir_shader_list, true, false);
#endif #endif
#endif #endif
@ -1535,10 +1535,10 @@ bool command_event(enum event_command cmd, void *data)
case CMD_EVENT_SHADER_PREV: case CMD_EVENT_SHADER_PREV:
#if defined(HAVE_CG) || defined(HAVE_GLSL) || defined(HAVE_SLANG) || defined(HAVE_HLSL) #if defined(HAVE_CG) || defined(HAVE_GLSL) || defined(HAVE_SLANG) || defined(HAVE_HLSL)
#ifdef HAVE_MENU #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); &video_st->dir_shader_list, false, true);
#else #else
dir_check_shader(NULL, settings, video_shader_dir_check_shader(NULL, settings,
&video_st->dir_shader_list, false, true); &video_st->dir_shader_list, false, true);
#endif #endif
#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); 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: * 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; 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); enum rarch_shader_type type = video_shader_parse_type(preset);
apply_shader(settings, type, preset, false); video_shader_apply_shader(settings, type, preset, false);
} }
} }
} }