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

(Video) use flags for FBO passes, GL2 renderchain, etc

Browse Source
This commit is contained in:
LibretroAdmin 2022-10-26 21:21:21 +02:00
parent fc78f96a3a
commit d0b3c1742d
21 changed files with 223 additions and 146 deletions

6
gfx/common/d3d9_common.c

@ -775,7 +775,7 @@ static void d3d9_init_singlepass(d3d9_video_t *d3d)
pass = (struct video_shader_pass*)
&d3d->shader.pass[0];
pass->fbo.valid = true;
pass->fbo.flags |= FBO_SCALE_FLAG_VALID;
pass->fbo.scale_y = 1.0;
pass->fbo.type_y = RARCH_SCALE_VIEWPORT;
pass->fbo.scale_x = pass->fbo.scale_y;
@ -801,7 +801,7 @@ static bool d3d9_init_multipass(d3d9_video_t *d3d, const char *shader_path)
for (i = 0; i < d3d->shader.passes; i++)
{
if (d3d->shader.pass[i].fbo.valid)
if (d3d->shader.pass[i].fbo.flags & FBO_SCALE_FLAG_VALID)
continue;
d3d->shader.pass[i].fbo.scale_y = 1.0f;
@ -811,7 +811,7 @@ static bool d3d9_init_multipass(d3d9_video_t *d3d, const char *shader_path)
}
use_extra_pass = d3d->shader.passes < GFX_MAX_SHADERS &&
d3d->shader.pass[d3d->shader.passes - 1].fbo.valid;
(d3d->shader.pass[d3d->shader.passes - 1].fbo.flags & FBO_SCALE_FLAG_VALID);
if (use_extra_pass)
{

2
gfx/common/metal_common.m

@ -1025,7 +1025,7 @@ typedef struct MTLALIGN(16)
{
struct video_shader_pass *shader_pass = &_shader->pass[i];
if (shader_pass->fbo.valid)
if (shader_pass->fbo.flags & FBO_SCALE_FLAG_VALID)
{
switch (shader_pass->fbo.type_x)
{

2
gfx/drivers/d3d10.c

@ -1163,7 +1163,7 @@ static void d3d10_init_render_targets(d3d10_video_t* d3d10,
{
struct video_shader_pass* pass = &d3d10->shader_preset->pass[i];
if (pass->fbo.valid)
if (pass->fbo.flags & FBO_SCALE_FLAG_VALID)
{
switch (pass->fbo.type_x)

2
gfx/drivers/d3d11.c

@ -1739,7 +1739,7 @@ static void d3d11_init_render_targets(d3d11_video_t* d3d11, unsigned width, unsi
{
struct video_shader_pass* pass = &d3d11->shader_preset->pass[i];
if (pass->fbo.valid)
if (pass->fbo.flags & FBO_SCALE_FLAG_VALID)
{
switch (pass->fbo.type_x)

2
gfx/drivers/d3d12.c

@ -1935,7 +1935,7 @@ static void d3d12_init_render_targets(d3d12_video_t* d3d12, unsigned width, unsi
{
struct video_shader_pass* pass = &d3d12->shader_preset->pass[i];
if (pass->fbo.valid)
if (pass->fbo.flags & FBO_SCALE_FLAG_VALID)
{
switch (pass->fbo.type_x)

2
gfx/drivers/d3d8.c

@ -1178,11 +1178,11 @@ static bool d3d8_init_internal(d3d8_video_t *d3d,
pass = (struct video_shader_pass*)
&d3d->shader.pass[0];
pass->fbo.valid = true;
pass->fbo.scale_y = 1.0;
pass->fbo.type_y = RARCH_SCALE_VIEWPORT;
pass->fbo.scale_x = pass->fbo.scale_y;
pass->fbo.type_x = pass->fbo.type_y;
pass->fbo.flags |= FBO_SCALE_FLAG_VALID;
if (!string_is_empty(d3d->shader_path))
strlcpy(pass->source.path, d3d->shader_path,

9
gfx/drivers/d3d9_renderchain.h

@ -115,8 +115,8 @@ static INLINE bool d3d9_renderchain_add_pass(d3d9_renderchain_t *chain,
info->tex_h,
1,
D3DUSAGE_RENDERTARGET,
chain->passes->data[
chain->passes->count - 1].info.pass->fbo.fp_fbo
(chain->passes->data[
chain->passes->count - 1].info.pass->fbo.flags & FBO_SCALE_FLAG_FP_FBO)
? D3DFMT_A32B32G32R32F : D3D9_ARGB8888_FORMAT,
D3DPOOL_DEFAULT, 0, 0, 0, NULL, NULL, false);
@ -285,8 +285,9 @@ static INLINE bool d3d9_renderchain_set_pass_size(
d3d9_texture_new(dev,
width, height, 1,
D3DUSAGE_RENDERTARGET,
pass2->info.pass->fbo.fp_fbo ?
D3DFMT_A32B32G32R32F : D3D9_ARGB8888_FORMAT,
(pass2->info.pass->fbo.flags & FBO_SCALE_FLAG_FP_FBO)
? D3DFMT_A32B32G32R32F
: D3D9_ARGB8888_FORMAT,
D3DPOOL_DEFAULT, 0, 0, 0,
NULL, NULL, false);

107
gfx/drivers/gl2.c

@ -159,6 +159,15 @@ typedef struct __GLsync *GLsync;
#endif
#endif
enum gl2_renderchain_flags
{
GL2_CHAIN_FLAG_EGL_IMAGES = (1 << 0),
GL2_CHAIN_FLAG_HAS_FP_FBO = (1 << 1),
GL2_CHAIN_FLAG_HAS_SRGB_FBO_GLES3 = (1 << 2),
GL2_CHAIN_FLAG_HAS_SRGB_FBO = (1 << 3),
GL2_CHAIN_FLAG_HW_RENDER_DEPTH_INIT = (1 << 4)
};
typedef struct gl2_renderchain_data
{
int fbo_pass;
@ -175,12 +184,7 @@ typedef struct gl2_renderchain_data
unsigned fence_count;
struct gfx_fbo_scale fbo_scale[GFX_MAX_SHADERS];
bool egl_images;
bool has_fp_fbo;
bool has_srgb_fbo_gles3;
bool has_srgb_fbo;
bool hw_render_depth_init;
uint8_t flags;
} gl2_renderchain_data_t;
#if (!defined(HAVE_OPENGLES) || defined(HAVE_OPENGLES3))
@ -273,7 +277,7 @@ static bool gl2_shader_scale(gl2_t *gl,
if (!scaler || !scaler->scale)
return false;
scaler->scale->valid = false;
scaler->scale->flags &= ~FBO_SCALE_FLAG_VALID;
gl->shader->shader_scale(gl->shader_data,
scaler->idx, scaler->scale);
@ -585,7 +589,7 @@ static void gl2_renderchain_render(
}
#if defined(GL_FRAMEBUFFER_SRGB) && !defined(HAVE_OPENGLES)
if (chain->has_srgb_fbo)
if (chain->flags & GL2_CHAIN_FLAG_HAS_SRGB_FBO)
glDisable(GL_FRAMEBUFFER_SRGB);
#endif
@ -694,7 +698,7 @@ static void gl2_renderchain_deinit_hw_render(
if (gl->hw_render_fbo_init)
gl2_delete_fb(gl->textures, gl->hw_render_fbo);
if (chain->hw_render_depth_init)
if (chain->flags & GL2_CHAIN_FLAG_HW_RENDER_DEPTH_INIT)
gl2_delete_rb(gl->textures, chain->hw_render_depth);
gl->hw_render_fbo_init = false;
@ -830,16 +834,17 @@ static void gl2_create_fbo_texture(gl2_t *gl,
GL2_BIND_TEXTURE(texture, wrap_enum, mag_filter, min_filter);
fp_fbo = chain->fbo_scale[i].fp_fbo;
fp_fbo = chain->fbo_scale[i].flags & FBO_SCALE_FLAG_FP_FBO;
if (fp_fbo)
{
if (!chain->has_fp_fbo)
if (!(chain->flags & GL2_CHAIN_FLAG_HAS_FP_FBO))
RARCH_ERR("[GL]: Floating-point FBO was requested, but is not supported. Falling back to UNORM. Result may band/clip/etc.!\n");
}
#if !defined(HAVE_OPENGLES2)
if (fp_fbo && chain->has_fp_fbo)
if ( fp_fbo
&& (chain->flags & GL2_CHAIN_FLAG_HAS_FP_FBO))
{
RARCH_LOG("[GL]: FBO pass #%d is floating-point.\n", i);
gl2_load_texture_image(GL_TEXTURE_2D, 0, GL_RGBA32F,
@ -850,18 +855,19 @@ static void gl2_create_fbo_texture(gl2_t *gl,
#endif
{
#ifndef HAVE_OPENGLES
bool srgb_fbo = chain->fbo_scale[i].srgb_fbo;
bool srgb_fbo = chain->fbo_scale[i].flags & FBO_SCALE_FLAG_SRGB_FBO;
if (!fp_fbo && srgb_fbo)
{
if (!chain->has_srgb_fbo)
if (!(chain->flags & GL2_CHAIN_FLAG_HAS_SRGB_FBO))
RARCH_ERR("[GL]: sRGB FBO was requested, but it is not supported. Falling back to UNORM. Result may have banding!\n");
}
if (force_srgb_disable)
srgb_fbo = false;
if (srgb_fbo && chain->has_srgb_fbo)
if ( srgb_fbo
&& (chain->flags & GL2_CHAIN_FLAG_HAS_SRGB_FBO))
{
RARCH_LOG("[GL]: FBO pass #%d is sRGB.\n", i);
#ifdef HAVE_OPENGLES2
@ -870,7 +876,9 @@ static void gl2_create_fbo_texture(gl2_t *gl,
glTexImage2D(GL_TEXTURE_2D,
0, GL_SRGB_ALPHA_EXT,
gl->fbo_rect[i].width, gl->fbo_rect[i].height, 0,
chain->has_srgb_fbo_gles3 ? GL_RGBA : GL_SRGB_ALPHA_EXT,
(chain->flags & GL2_CHAIN_FLAG_HAS_SRGB_FBO_GLES3)
? GL_RGBA
: GL_SRGB_ALPHA_EXT,
GL_UNSIGNED_BYTE, NULL);
#else
gl2_load_texture_image(GL_TEXTURE_2D,
@ -1062,7 +1070,7 @@ static void gl2_renderchain_start_render(
gl->coords.vertex = fbo_vertexes;
#if defined(GL_FRAMEBUFFER_SRGB) && !defined(HAVE_OPENGLES)
if (chain->has_srgb_fbo)
if (chain->flags & GL2_CHAIN_FLAG_HAS_SRGB_FBO)
glEnable(GL_FRAMEBUFFER_SRGB);
#endif
}
@ -1099,7 +1107,8 @@ static void gl2_renderchain_init(
gl2_shader_scale(gl, &scaler);
/* we always want FBO to be at least initialized on startup for consoles */
if (shader_info.num == 1 && !scale.valid)
if ( shader_info.num == 1
&& (!(scale.flags & FBO_SCALE_FLAG_VALID)))
return;
if (!gl->has_fbo)
@ -1109,15 +1118,16 @@ static void gl2_renderchain_init(
}
chain->fbo_pass = shader_info.num - 1;
if (scale_last.valid)
if (scale_last.flags & FBO_SCALE_FLAG_VALID)
chain->fbo_pass++;
if (!scale.valid)
if (!(scale.flags & FBO_SCALE_FLAG_VALID))
{
scale.scale_x = 1.0f;
scale.scale_y = 1.0f;
scale.type_x = scale.type_y = RARCH_SCALE_INPUT;
scale.valid = true;
scale.scale_x = 1.0f;
scale.scale_y = 1.0f;
scale.type_x = RARCH_SCALE_INPUT;
scale.type_y = RARCH_SCALE_INPUT;
scale.flags |= FBO_SCALE_FLAG_VALID;
}
chain->fbo_scale[0] = scale;
@ -1129,12 +1139,12 @@ static void gl2_renderchain_init(
gl2_shader_scale(gl, &scaler);
if (!chain->fbo_scale[i].valid)
if (!(chain->fbo_scale[i].flags & FBO_SCALE_FLAG_VALID))
{
chain->fbo_scale[i].scale_x = chain->fbo_scale[i].scale_y = 1.0f;
chain->fbo_scale[i].type_x = chain->fbo_scale[i].type_y =
RARCH_SCALE_INPUT;
chain->fbo_scale[i].valid = true;
chain->fbo_scale[i].flags |= FBO_SCALE_FLAG_VALID;
}
}
@ -1215,7 +1225,7 @@ static bool gl2_renderchain_init_hw_render(
if (depth)
{
gl2_gen_rb(gl->textures, chain->hw_render_depth);
chain->hw_render_depth_init = true;
chain->flags |= GL2_CHAIN_FLAG_HW_RENDER_DEPTH_INIT;
}
for (i = 0; i < gl->textures; i++)
@ -1438,7 +1448,7 @@ static void gl2_renderchain_copy_frame(
}
#elif defined(HAVE_OPENGLES)
#if defined(HAVE_EGL)
if (chain->egl_images)
if (chain->flags & GL2_CHAIN_FLAG_EGL_IMAGES)
{
bool new_egl = false;
EGLImageKHR img = 0;
@ -1631,7 +1641,7 @@ static void gl2_renderchain_init_texture_reference(
gl->tex_w * gl->base_size,
gl->tex_w * gl->tex_h * i * gl->base_size);
#else
if (chain->egl_images)
if (chain->flags & GL2_CHAIN_FLAG_EGL_IMAGES)
return;
gl2_load_texture_image(GL_TEXTURE_2D,
@ -1655,19 +1665,33 @@ static void gl2_renderchain_resolve_extensions(gl2_t *gl,
if (!chain)
return;
chain->has_srgb_fbo = false;
chain->has_fp_fbo = gl_check_capability(GL_CAPS_FP_FBO);
chain->flags &= ~GL2_CHAIN_FLAG_HAS_SRGB_FBO;
if (gl_check_capability(GL_CAPS_FP_FBO))
chain->flags |= GL2_CHAIN_FLAG_HAS_FP_FBO;
else
chain->flags &= ~GL2_CHAIN_FLAG_HAS_FP_FBO;
/* GLES3 has unpack_subimage and sRGB in core. */
chain->has_srgb_fbo_gles3 = gl_check_capability(GL_CAPS_SRGB_FBO_ES3);
if (gl_check_capability(GL_CAPS_SRGB_FBO_ES3))
chain->flags |= GL2_CHAIN_FLAG_HAS_SRGB_FBO_GLES3;
else
chain->flags &= ~GL2_CHAIN_FLAG_HAS_SRGB_FBO_GLES3;
if (!force_srgb_disable)
chain->has_srgb_fbo = gl_check_capability(GL_CAPS_SRGB_FBO);
{
if (gl_check_capability(GL_CAPS_SRGB_FBO))
chain->flags |= GL2_CHAIN_FLAG_HAS_SRGB_FBO;
else
chain->flags &= ~GL2_CHAIN_FLAG_HAS_SRGB_FBO;
}
/* Use regular textures if we use HW render. */
chain->egl_images = !gl->hw_render_use
if ( !gl->hw_render_use
&& gl_check_capability(GL_CAPS_EGLIMAGE)
&& gl->ctx_driver->image_buffer_init
&& gl->ctx_driver->image_buffer_init(gl->ctx_data, video);
&& gl->ctx_driver->image_buffer_init(gl->ctx_data, video))
chain->flags |= GL2_CHAIN_FLAG_EGL_IMAGES;
else
chain->flags &= ~GL2_CHAIN_FLAG_EGL_IMAGES;
}
static void gl_load_texture_data(
@ -1729,10 +1753,17 @@ static void gl_load_texture_data(
glPixelStorei(GL_UNPACK_ALIGNMENT, alignment);
glTexImage2D(GL_TEXTURE_2D,
0,
(use_rgba || !rgb32) ? GL_RGBA : RARCH_GL_INTERNAL_FORMAT32,
(use_rgba || !rgb32)
? GL_RGBA
: RARCH_GL_INTERNAL_FORMAT32,
width, height, 0,
(use_rgba || !rgb32) ? GL_RGBA : RARCH_GL_TEXTURE_TYPE32,
(rgb32) ? RARCH_GL_FORMAT32 : GL_UNSIGNED_SHORT_4_4_4_4, frame);
(use_rgba || !rgb32)
? GL_RGBA
: RARCH_GL_TEXTURE_TYPE32,
(rgb32)
? RARCH_GL_FORMAT32
: GL_UNSIGNED_SHORT_4_4_4_4,
frame);
if (want_mipmap && have_mipmap)
glGenerateMipmap(GL_TEXTURE_2D);

10
gfx/drivers/gx2_gfx.c

@ -873,10 +873,12 @@ static bool wiiu_init_frame_textures(wiiu_video_t *wiiu, unsigned width, unsigne
#if 0
wiiu->pass[i].texture.surface.mipLevels = 1;
#endif
wiiu->pass[i].texture.surface.format = pass->fbo.fp_fbo ?
GX2_SURFACE_FORMAT_FLOAT_R32_G32_B32_A32 :
pass->fbo.srgb_fbo ? GX2_SURFACE_FORMAT_SRGB_R8_G8_B8_A8 :
GX2_SURFACE_FORMAT_UNORM_R8_G8_B8_A8;
wiiu->pass[i].texture.surface.format =
(pass->fbo.flags & FBO_SCALE_FLAG_FP_FBO)
? GX2_SURFACE_FORMAT_FLOAT_R32_G32_B32_A32
: (pass->fbo.flags & FBO_SCALE_FLAG_SRGB_FBO)
? GX2_SURFACE_FORMAT_SRGB_R8_G8_B8_A8
: GX2_SURFACE_FORMAT_UNORM_R8_G8_B8_A8;
wiiu->pass[i].texture.surface.use = (GX2_SURFACE_USE_TEXTURE |
GX2_SURFACE_USE_COLOR_BUFFER);
wiiu->pass[i].texture.viewNumSlices = 1;

9
gfx/drivers_shader/shader_gl3.cpp

@ -2226,7 +2226,8 @@ gl3_filter_chain_t *gl3_filter_chain_create_from_preset(
if (!video_shader_load_preset_into_shader(path, shader.get()))
return nullptr;
bool last_pass_is_fbo = shader->pass[shader->passes - 1].fbo.valid;
bool last_pass_is_fbo = shader->pass[shader->passes - 1].fbo.flags &
FBO_SCALE_FLAG_VALID;
std::unique_ptr<gl3_filter_chain> chain{ new gl3_filter_chain(shader->passes + (last_pass_is_fbo ? 1 : 0)) };
if (!chain)
@ -2355,7 +2356,7 @@ gl3_filter_chain_t *gl3_filter_chain_create_from_preset(
if (output.meta.rt_format == SLANG_FORMAT_UNKNOWN)
output.meta.rt_format = SLANG_FORMAT_R8G8B8A8_UNORM;
if (!pass->fbo.valid)
if (!(pass->fbo.flags & FBO_SCALE_FLAG_VALID))
{
bool scale_viewport = i + 1 == shader->passes;
if (scale_viewport)
@ -2390,9 +2391,9 @@ gl3_filter_chain_t *gl3_filter_chain_create_from_preset(
{
/* Preset overrides shader.
* Kinda ugly ... */
if (pass->fbo.srgb_fbo)
if (pass->fbo.flags & FBO_SCALE_FLAG_SRGB_FBO)
output.meta.rt_format = SLANG_FORMAT_R8G8B8A8_SRGB;
else if (pass->fbo.fp_fbo)
else if (pass->fbo.flags & FBO_SCALE_FLAG_FP_FBO)
output.meta.rt_format = SLANG_FORMAT_R16G16B16A16_SFLOAT;
pass_info.rt_format = gl3_shader::convert_glslang_format(output.meta.rt_format);

28
gfx/drivers_shader/shader_glsl.c

@ -1041,14 +1041,14 @@ static void *gl_glsl_init(void *data, const char *path)
if (is_preset)
{
ret = video_shader_load_preset_into_shader(path, glsl->shader);
glsl->shader->modern = true;
glsl->shader->flags |= SHDR_FLAG_MODERN;
}
else
{
strlcpy(glsl->shader->pass[0].source.path, path,
sizeof(glsl->shader->pass[0].source.path));
glsl->shader->passes = 1;
glsl->shader->modern = true;
glsl->shader->flags |= SHDR_FLAG_MODERN;
ret = true;
}
@ -1071,7 +1071,7 @@ static void *gl_glsl_init(void *data, const char *path)
glsl->shader->pass[0].source.string.fragment =
strdup(glsl_core ? stock_fragment_core : stock_fragment_modern);
#endif
glsl->shader->modern = true;
glsl->shader->flags |= SHDR_FLAG_MODERN;
}
}
@ -1079,9 +1079,9 @@ static void *gl_glsl_init(void *data, const char *path)
stock_vertex = stock_vertex_modern;
stock_fragment = stock_fragment_modern;
#else
stock_vertex = (glsl->shader->modern) ?
stock_vertex = (glsl->shader->flags & SHDR_FLAG_MODERN) ?
stock_vertex_modern : stock_vertex_legacy;
stock_fragment = (glsl->shader->modern) ?
stock_fragment = (glsl->shader->flags & SHDR_FLAG_MODERN) ?
stock_fragment_modern : stock_fragment_legacy;
if (glsl_core)
@ -1092,13 +1092,14 @@ static void *gl_glsl_init(void *data, const char *path)
#endif
#ifdef HAVE_OPENGLES
if (!glsl->shader->modern)
if (!glsl->shader->flags & SHDR_FLAG_MODERN)
{
RARCH_ERR("[GL]: GLES context is used, but shader is not modern. Cannot use it.\n");
goto error;
}
#else
if (glsl_core && !glsl->shader->modern)
if ( glsl_core
&& (!(glsl->shader->flags & SHDR_FLAG_MODERN)))
{
RARCH_ERR("[GL]: GL core context is used, but shader is not core compatible. Cannot use it.\n");
goto error;
@ -1156,7 +1157,7 @@ static void *gl_glsl_init(void *data, const char *path)
glsl->prg[glsl->shader->passes + 1] = glsl->prg[0];
glsl->uniforms[glsl->shader->passes + 1] = glsl->uniforms[0];
if (glsl->shader->modern)
if (glsl->shader->flags & SHDR_FLAG_MODERN)
{
#if defined(VITA)
shader_prog_info.vertex = stock_vertex_modern_blend;
@ -1519,7 +1520,8 @@ static bool gl_glsl_set_mvp(void *shader_data, const void *mat_data)
int loc;
glsl_shader_data_t *glsl = (glsl_shader_data_t*)shader_data;
if (!glsl || !glsl->shader->modern)
if ( !glsl
|| (!(glsl->shader->flags & SHDR_FLAG_MODERN)))
return false;
loc = glsl->uniforms[glsl->active_idx].mvp;
@ -1562,7 +1564,9 @@ static bool gl_glsl_set_coords(void *shader_data,
const struct shader_uniforms *uni = glsl
? &glsl->uniforms[glsl->active_idx] : NULL;
if (!glsl || !glsl->shader->modern || !coords)
if ( !glsl
|| (!(glsl->shader->flags & SHDR_FLAG_MODERN))
|| !coords)
{
if (coords)
return false;
@ -1689,9 +1693,9 @@ static void gl_glsl_shader_scale(void *data, unsigned idx, struct gfx_fbo_scale
{
glsl_shader_data_t *glsl = (glsl_shader_data_t*)data;
if (glsl && idx)
*scale = glsl->shader->pass[idx - 1].fbo;
*scale = glsl->shader->pass[idx - 1].fbo;
else
scale->valid = false;
scale->flags &= ~FBO_SCALE_FLAG_VALID;
}
static unsigned gl_glsl_get_prev_textures(void *data)

9
gfx/drivers_shader/shader_vulkan.cpp

@ -2898,7 +2898,8 @@ vulkan_filter_chain_t *vulkan_filter_chain_create_from_preset(
if (!video_shader_load_preset_into_shader(path, shader.get()))
return nullptr;
bool last_pass_is_fbo = shader->pass[shader->passes - 1].fbo.valid;
bool last_pass_is_fbo = shader->pass[shader->passes - 1].fbo.flags &
FBO_SCALE_FLAG_VALID;
auto tmpinfo = *info;
tmpinfo.num_passes = shader->passes + (last_pass_is_fbo ? 1 : 0);
@ -3029,7 +3030,7 @@ vulkan_filter_chain_t *vulkan_filter_chain_create_from_preset(
if (output.meta.rt_format == SLANG_FORMAT_UNKNOWN)
output.meta.rt_format = SLANG_FORMAT_R8G8B8A8_UNORM;
if (!pass->fbo.valid)
if (!(pass->fbo.flags & FBO_SCALE_FLAG_VALID))
{
pass_info.scale_type_x = GLSLANG_FILTER_CHAIN_SCALE_SOURCE;
pass_info.scale_type_y = GLSLANG_FILTER_CHAIN_SCALE_SOURCE;
@ -3067,9 +3068,9 @@ vulkan_filter_chain_t *vulkan_filter_chain_create_from_preset(
{
/* Preset overrides shader.
* Kinda ugly ... */
if (pass->fbo.srgb_fbo)
if (pass->fbo.flags & FBO_SCALE_FLAG_SRGB_FBO)
output.meta.rt_format = SLANG_FORMAT_R8G8B8A8_SRGB;
else if (pass->fbo.fp_fbo)
else if (pass->fbo.flags & FBO_SCALE_FLAG_FP_FBO)
output.meta.rt_format = SLANG_FORMAT_R16G16B16A16_SFLOAT;
pass_info.rt_format = glslang_format_to_vk(output.meta.rt_format);

4
gfx/drivers_shader/slang_process.cpp

@ -432,9 +432,9 @@ bool slang_process(
if (out->format == SLANG_FORMAT_UNKNOWN)
{
if (pass.fbo.srgb_fbo)
if (pass.fbo.flags & FBO_SCALE_FLAG_SRGB_FBO)
out->format = SLANG_FORMAT_R8G8B8A8_SRGB;
else if (pass.fbo.fp_fbo)
else if (pass.fbo.flags & FBO_SCALE_FLAG_FP_FBO)
out->format = SLANG_FORMAT_R16G16B16A16_SFLOAT;
else
out->format = SLANG_FORMAT_R8G8B8A8_UNORM;

34
gfx/video_shader_parse.c

@ -276,12 +276,22 @@ static bool video_shader_parse_pass(config_file_t *conf,
strlcpy(srgb_output_buf, "srgb_framebuffer", sizeof(srgb_output_buf));
strlcat(srgb_output_buf, formatted_num, sizeof(srgb_output_buf));
if (config_get_bool(conf, srgb_output_buf, &tmp_bool))
pass->fbo.srgb_fbo = tmp_bool;
{
if (tmp_bool)
pass->fbo.flags |= FBO_SCALE_FLAG_SRGB_FBO;
else
pass->fbo.flags &= ~FBO_SCALE_FLAG_SRGB_FBO;
}
strlcpy(fp_fbo_buf, "float_framebuffer", sizeof(fp_fbo_buf));
strlcat(fp_fbo_buf, formatted_num, sizeof(fp_fbo_buf));
if (config_get_bool(conf, fp_fbo_buf, &tmp_bool))
pass->fbo.fp_fbo = tmp_bool;
{
if (tmp_bool)
pass->fbo.flags |= FBO_SCALE_FLAG_FP_FBO;
else
pass->fbo.flags &= ~FBO_SCALE_FLAG_FP_FBO;
}
strlcpy(mipmap_buf, "mipmap_input", sizeof(mipmap_buf));
strlcat(mipmap_buf, formatted_num, sizeof(mipmap_buf));
@ -315,7 +325,7 @@ static bool video_shader_parse_pass(config_file_t *conf,
else if (!*scale_type_x && !*scale_type_y)
return true;
scale->valid = true;
scale->flags |= FBO_SCALE_FLAG_VALID;
scale->type_x = RARCH_SCALE_INPUT;
scale->type_y = RARCH_SCALE_INPUT;
scale->scale_x = 1.0;
@ -746,12 +756,12 @@ static void shader_write_fbo(config_file_t *conf,
char key[64];
strlcpy(key, "float_framebuffer", sizeof(key));
strlcat(key, formatted_num, sizeof(key));
config_set_string(conf, key, fbo->fp_fbo ? "true" : "false");
config_set_string(conf, key, (fbo->flags & FBO_SCALE_FLAG_FP_FBO) ? "true" : "false");
strlcpy(key, "srgb_framebuffer", sizeof(key));
strlcat(key, formatted_num, sizeof(key));
config_set_string(conf, key, fbo->srgb_fbo ? "true" : "false");
config_set_string(conf, key, (fbo->flags & FBO_SCALE_FLAG_SRGB_FBO) ? "true" : "false");
if (!fbo->valid)
if (!(fbo->flags & FBO_SCALE_FLAG_VALID))
return;
shader_write_scale_dim(conf, "x", formatted_num, fbo->type_x, fbo->scale_x, fbo->abs_x);
@ -1419,7 +1429,8 @@ static bool video_shader_write_referenced_preset(
continue_saving_ref = false;
}
if (continue_saving_ref && fbo->fp_fbo != root_fbo->fp_fbo)
if ( continue_saving_ref
&& (fbo->flags & FBO_SCALE_FLAG_FP_FBO) != (root_fbo->flags & FBO_SCALE_FLAG_FP_FBO))
{
#ifdef DEBUG
RARCH_WARN("[Shaders]: Pass %u fp_fbo", i);
@ -1427,7 +1438,9 @@ static bool video_shader_write_referenced_preset(
continue_saving_ref = false;
}
if (continue_saving_ref && fbo->srgb_fbo != root_fbo->srgb_fbo)
if (continue_saving_ref
&& (fbo->flags & FBO_SCALE_FLAG_SRGB_FBO) != (root_fbo->flags &
FBO_SCALE_FLAG_SRGB_FBO))
{
#ifdef DEBUG
RARCH_WARN("[Shaders]: Pass %u srgb_fbo", i);
@ -1435,7 +1448,8 @@ static bool video_shader_write_referenced_preset(
continue_saving_ref = false;
}
if (continue_saving_ref && fbo->valid != root_fbo->valid)
if (continue_saving_ref
&& ((fbo->flags & FBO_SCALE_FLAG_VALID) != (root_fbo->flags & FBO_SCALE_FLAG_VALID)))
{
#ifdef DEBUG
RARCH_WARN("[Shaders]: Pass %u valid", i);
@ -2522,7 +2536,7 @@ bool apply_shader(
/* reflect in shader manager */
if (menu_shader_manager_set_preset(
shader, type, preset_path, false))
shader->modified = false;
shader->flags &= ~SHDR_FLAG_MODIFIED;
#endif
}
else

30
gfx/video_shader_parse.h

@ -80,6 +80,13 @@ enum gfx_wrap_type
RARCH_WRAP_MAX
};
enum gfx_fbo_scale_flags
{
FBO_SCALE_FLAG_FP_FBO = (1 << 0),
FBO_SCALE_FLAG_SRGB_FBO = (1 << 1),
FBO_SCALE_FLAG_VALID = (1 << 2)
};
struct gfx_fbo_scale
{
unsigned abs_x;
@ -88,9 +95,7 @@ struct gfx_fbo_scale
float scale_y;
enum gfx_scale_type type_x;
enum gfx_scale_type type_y;
bool fp_fbo;
bool srgb_fbo;
bool valid;
uint8_t flags;
};
struct video_shader_parameter
@ -143,6 +148,14 @@ struct video_shader_lut
bool mipmap;
};
enum video_shader_flags
{
SHDR_FLAG_MODERN = (1 << 0), /* Only used for XML shaders. */
/* Indicative of whether shader was modified -
* for instance from the menus */
SHDR_FLAG_MODIFIED = (1 << 1)
};
/* This is pretty big, shouldn't be put on the stack.
* Avoid lots of allocation for convenience. */
struct video_shader
@ -160,19 +173,18 @@ struct video_shader
unsigned num_parameters;
unsigned variables;
uint8_t flags;
char prefix[64];
/* Path to the root preset */
char path[PATH_MAX_LENGTH];
/* Path to the original preset loaded, if this is a preset with the #reference
* directive then this will be different than the path*/
/* Path to the original preset loaded, if this is a preset
* with the #reference directive, then this will be different
* than the path */
char loaded_preset_path[PATH_MAX_LENGTH];
bool modern; /* Only used for XML shaders. */
/* indicative of whether shader was modified -
* for instance from the menus */
bool modified;
};

23
menu/cbs/menu_cbs_left.c

@ -90,7 +90,7 @@ static int shader_action_parameter_left_internal(unsigned type, const char *labe
param_menu->current = param_prev->current;
shader->modified = true;
shader->flags |= SHDR_FLAG_MODIFIED;
return ret;
}
@ -307,15 +307,18 @@ static int action_left_shader_scale_pass(unsigned type, const char *label,
return menu_cbs_exit();
/* A 20x scale is used to support scaling handheld border shaders up to 8K resolutions */
current_scale = shader_pass->fbo.scale_x;
delta = 20;
current_scale = (current_scale + delta) % 21;
current_scale = shader_pass->fbo.scale_x;
delta = 20;
current_scale = (current_scale + delta) % 21;
shader_pass->fbo.valid = current_scale;
shader_pass->fbo.scale_x = current_scale;
shader_pass->fbo.scale_y = current_scale;
if (current_scale)
shader_pass->fbo.flags |= FBO_SCALE_FLAG_VALID;
else
shader_pass->fbo.flags &= ~FBO_SCALE_FLAG_VALID;
shader_pass->fbo.scale_x = current_scale;
shader_pass->fbo.scale_y = current_scale;
shader->modified = true;
shader->flags |= SHDR_FLAG_MODIFIED;
return 0;
}
@ -332,7 +335,7 @@ static int action_left_shader_filter_pass(unsigned type, const char *label,
return menu_cbs_exit();
shader_pass->filter = ((shader_pass->filter + delta) % 3);
shader->modified = true;
shader->flags |= SHDR_FLAG_MODIFIED;
return 0;
}
@ -384,7 +387,7 @@ static int action_left_shader_num_passes(unsigned type, const char *label,
menu_driver_ctl(RARCH_MENU_CTL_SET_PREVENT_POPULATE, NULL);
video_shader_resolve_parameters(shader);
shader->modified = true;
shader->flags |= SHDR_FLAG_MODIFIED;
return 0;
}

8
menu/cbs/menu_cbs_ok.c

@ -2058,7 +2058,7 @@ static int generic_action_ok(const char *path,
sizeof(shader_pass->source.path));
video_shader_resolve_parameters(shader);
shader->modified = true;
shader->flags |= SHDR_FLAG_MODIFIED;
}
}
#endif
@ -6477,11 +6477,11 @@ static int action_ok_push_dropdown_item_video_shader_num_pass(const char *path,
if (!shader)
return menu_cbs_exit();
shader->passes = (unsigned)idx;
shader->passes = (unsigned)idx;
video_shader_resolve_parameters(shader);
shader->modified = true;
shader->flags |= SHDR_FLAG_MODIFIED;
return action_cancel_pop_default(NULL, NULL, 0, 0);
#else
@ -6513,7 +6513,7 @@ static int action_ok_push_dropdown_item_video_shader_param_generic(const char *p
param_prev->current = val;
param_menu->current = param_prev->current;
shader->modified = true;
shader->flags |= SHDR_FLAG_MODIFIED;
return action_cancel_pop_default(NULL, NULL, 0, 0);
#else

21
menu/cbs/menu_cbs_right.c

@ -89,7 +89,7 @@ static int generic_shader_action_parameter_right_internal(unsigned type, const c
ret = generic_shader_action_parameter_right(param_prev, type, label, wraparound);
param_menu->current = param_prev->current;
shader->modified = true;
shader->flags |= SHDR_FLAG_MODIFIED;
return ret;
}
@ -349,14 +349,17 @@ static int action_right_shader_scale_pass(unsigned type, const char *label,
return menu_cbs_exit();
/* A 20x scale is used to support scaling handheld border shaders up to 8K resolutions */
current_scale = shader_pass->fbo.scale_x;
delta = 1;
current_scale = (current_scale + delta) % 21;
current_scale = shader_pass->fbo.scale_x;
delta = 1;
current_scale = (current_scale + delta) % 21;
shader_pass->fbo.valid = current_scale;
shader_pass->fbo.scale_x = shader_pass->fbo.scale_y = current_scale;
shader_pass->fbo.scale_x = shader_pass->fbo.scale_y = current_scale;
if (current_scale)
shader_pass->fbo.flags |= FBO_SCALE_FLAG_VALID;
else
shader_pass->fbo.flags &= ~FBO_SCALE_FLAG_VALID;
shader->modified = true;
shader->flags |= SHDR_FLAG_MODIFIED;
return 0;
}
@ -374,7 +377,7 @@ static int action_right_shader_filter_pass(unsigned type, const char *label,
shader_pass->filter = ((shader_pass->filter + delta) % 3);
shader->modified = true;
shader->flags |= SHDR_FLAG_MODIFIED;
return 0;
}
@ -407,7 +410,7 @@ static int action_right_shader_num_passes(unsigned type, const char *label,
menu_driver_ctl(RARCH_MENU_CTL_SET_PREVENT_POPULATE, NULL);
video_shader_resolve_parameters(shader);
shader->modified = true;
shader->flags |= SHDR_FLAG_MODIFIED;
return 0;
}

15
menu/menu_driver.c

@ -2772,7 +2772,7 @@ int menu_shader_manager_clear_num_passes(struct video_shader *shader)
video_shader_resolve_parameters(shader);
shader->modified = true;
shader->flags |= SHDR_FLAG_MODIFIED;
return 0;
}
@ -2790,7 +2790,7 @@ int menu_shader_manager_clear_parameter(struct video_shader *shader,
param->current = MIN(MAX(param->minimum,
param->current), param->maximum);
shader->modified = true;
shader->flags |= SHDR_FLAG_MODIFIED;
return 0;
}
@ -2805,8 +2805,7 @@ int menu_shader_manager_clear_pass_filter(struct video_shader *shader,
return -1;
shader_pass->filter = RARCH_FILTER_UNSPEC;
shader->modified = true;
shader->flags |= SHDR_FLAG_MODIFIED;
return 0;
}
@ -2822,9 +2821,9 @@ void menu_shader_manager_clear_pass_scale(struct video_shader *shader,
shader_pass->fbo.scale_x = 0;
shader_pass->fbo.scale_y = 0;
shader_pass->fbo.valid = false;
shader_pass->fbo.flags &= ~FBO_SCALE_FLAG_VALID;
shader->modified = true;
shader->flags |= SHDR_FLAG_MODIFIED;
}
void menu_shader_manager_clear_pass_path(struct video_shader *shader,
@ -2839,7 +2838,7 @@ void menu_shader_manager_clear_pass_path(struct video_shader *shader,
*shader_pass->source.path = '\0';
if (shader)
shader->modified = true;
shader->flags |= SHDR_FLAG_MODIFIED;
}
/**
@ -7315,7 +7314,7 @@ bool menu_shader_manager_init(void)
ret = false;
goto end;
}
menu_shader->modified = false;
menu_shader->flags &= ~SHDR_FLAG_MODIFIED;
}
else
{

2
menu/menu_setting.c

@ -7817,7 +7817,7 @@ static void general_write_handler(rarch_setting_t *setting)
struct video_shader *shader = menu_shader_get();
shader->passes = 0;
shader->modified = true;
shader->flags |= SHDR_FLAG_MODIFIED;
menu_entries_ctl(MENU_ENTRIES_CTL_SET_REFRESH, &refresh);
menu_driver_ctl(RARCH_MENU_CTL_SET_PREVENT_POPULATE, NULL);

44
ui/drivers/qt/qt_dialogs.cpp

@ -1509,7 +1509,7 @@ void ShaderParamsDialog::onFilterComboBoxIndexChanged(int)
if (video_shader)
video_shader->pass[pass].filter = filter;
video_shader->modified = true;
video_shader->flags |= SHDR_FLAG_MODIFIED;
command_event(CMD_EVENT_SHADERS_APPLY_CHANGES, NULL);
}
@ -1553,19 +1553,25 @@ void ShaderParamsDialog::onScaleComboBoxIndexChanged(int)
{
if (menu_shader)
{
menu_shader->pass[pass].fbo.scale_x = scale;
menu_shader->pass[pass].fbo.scale_y = scale;
menu_shader->pass[pass].fbo.valid = scale;
menu_shader->pass[pass].fbo.scale_x = scale;
menu_shader->pass[pass].fbo.scale_y = scale;
if (scale)
menu_shader->pass[pass].fbo.flags |= FBO_SCALE_FLAG_VALID;
else
menu_shader->pass[pass].fbo.flags &= ~FBO_SCALE_FLAG_VALID;
}
if (video_shader)
{
video_shader->pass[pass].fbo.scale_x = scale;
video_shader->pass[pass].fbo.scale_y = scale;
video_shader->pass[pass].fbo.valid = scale;
video_shader->pass[pass].fbo.scale_x = scale;
video_shader->pass[pass].fbo.scale_y = scale;
if (scale)
video_shader->pass[pass].fbo.flags |= FBO_SCALE_FLAG_VALID;
else
video_shader->pass[pass].fbo.flags &= ~FBO_SCALE_FLAG_VALID;
}
video_shader->modified = true;
video_shader->flags |= SHDR_FLAG_MODIFIED;
command_event(CMD_EVENT_SHADERS_APPLY_CHANGES, NULL);
}
@ -1643,7 +1649,7 @@ void ShaderParamsDialog::onShaderPassMoveDownClicked()
memcpy(&menu_shader->pass[pass + 1], tempPass.pass, sizeof(struct video_shader_pass));
}
menu_shader->modified = true;
menu_shader->flags |= SHDR_FLAG_MODIFIED;
reload();
}
@ -1718,7 +1724,7 @@ void ShaderParamsDialog::onShaderPassMoveUpClicked()
memcpy(&menu_shader->pass[pass], tempPass.pass, sizeof(struct video_shader_pass));
}
menu_shader->modified = true;
menu_shader->flags |= SHDR_FLAG_MODIFIED;
reload();
}
@ -1825,7 +1831,7 @@ void ShaderParamsDialog::onShaderResetPass(int pass)
param->current = param->initial;
}
video_shader->modified = true;
video_shader->flags |= SHDR_FLAG_MODIFIED;
}
reload();
@ -1871,7 +1877,7 @@ void ShaderParamsDialog::onShaderResetParameter(QString parameter)
if (param)
param->current = param->initial;
video_shader->modified = true;
video_shader->flags |= SHDR_FLAG_MODIFIED;
}
reload();
@ -1941,7 +1947,7 @@ void ShaderParamsDialog::onShaderAddPassClicked()
else
return;
menu_shader->modified = true;
menu_shader->flags |= SHDR_FLAG_MODIFIED;
shader_pass = &menu_shader->pass[menu_shader->passes - 1];
if (!shader_pass)
@ -2122,7 +2128,7 @@ void ShaderParamsDialog::onShaderRemoveAllPassesClicked()
return;
menu_shader->passes = 0;
menu_shader->modified = true;
menu_shader->flags |= SHDR_FLAG_MODIFIED;
onShaderApplyClicked();
}
@ -2169,7 +2175,7 @@ void ShaderParamsDialog::onShaderRemovePass(int pass)
menu_shader->passes--;
menu_shader->modified = true;
menu_shader->flags |= SHDR_FLAG_MODIFIED;
onShaderApplyClicked();
}
@ -2721,7 +2727,7 @@ void ShaderParamsDialog::onShaderParamCheckBoxClicked()
param->current = (checkBox->isChecked() ? param->maximum : param->minimum);
}
video_shader->modified = true;
video_shader->flags |= SHDR_FLAG_MODIFIED;
}
}
@ -2787,7 +2793,7 @@ void ShaderParamsDialog::onShaderParamSliderValueChanged(int)
param->current = newValue;
}
video_shader->modified = true;
video_shader->flags |= SHDR_FLAG_MODIFIED;
}
}
@ -2895,7 +2901,7 @@ void ShaderParamsDialog::onShaderParamSpinBoxValueChanged(int value)
slider->blockSignals(false);
}
video_shader->modified = true;
video_shader->flags |= SHDR_FLAG_MODIFIED;
}
}
}
@ -2978,7 +2984,7 @@ void ShaderParamsDialog::onShaderParamDoubleSpinBoxValueChanged(double value)
slider->blockSignals(false);
}
video_shader->modified = true;
video_shader->flags |= SHDR_FLAG_MODIFIED;
}
}
}