diff --git a/gfx/common/d3d9_common.c b/gfx/common/d3d9_common.c
index 618d23e891..7188183628 100644
--- a/gfx/common/d3d9_common.c
+++ b/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)
    {
diff --git a/gfx/common/metal_common.m b/gfx/common/metal_common.m
index 29b7e4a231..cac9ed0714 100644
--- a/gfx/common/metal_common.m
+++ b/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)
          {
diff --git a/gfx/drivers/d3d10.c b/gfx/drivers/d3d10.c
index aa56a9872f..c1ef2643bd 100644
--- a/gfx/drivers/d3d10.c
+++ b/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)
diff --git a/gfx/drivers/d3d11.c b/gfx/drivers/d3d11.c
index 68be9e86d4..f6641dc983 100644
--- a/gfx/drivers/d3d11.c
+++ b/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)
diff --git a/gfx/drivers/d3d12.c b/gfx/drivers/d3d12.c
index 7ad1de53ba..4b585c4072 100644
--- a/gfx/drivers/d3d12.c
+++ b/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)
diff --git a/gfx/drivers/d3d8.c b/gfx/drivers/d3d8.c
index 579dc26d1f..f577a159a0 100644
--- a/gfx/drivers/d3d8.c
+++ b/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,
diff --git a/gfx/drivers/d3d9_renderchain.h b/gfx/drivers/d3d9_renderchain.h
index e5b0011ea4..9477297704 100644
--- a/gfx/drivers/d3d9_renderchain.h
+++ b/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);
 
diff --git a/gfx/drivers/gl2.c b/gfx/drivers/gl2.c
index 114752bab7..b2c5c71388 100644
--- a/gfx/drivers/gl2.c
+++ b/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);
diff --git a/gfx/drivers/gx2_gfx.c b/gfx/drivers/gx2_gfx.c
index 1c8686b10c..202335cb46 100644
--- a/gfx/drivers/gx2_gfx.c
+++ b/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;
diff --git a/gfx/drivers_shader/shader_gl3.cpp b/gfx/drivers_shader/shader_gl3.cpp
index 2e18355b49..06ace051dc 100644
--- a/gfx/drivers_shader/shader_gl3.cpp
+++ b/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);
diff --git a/gfx/drivers_shader/shader_glsl.c b/gfx/drivers_shader/shader_glsl.c
index 1781a4b28d..3c2fd43680 100644
--- a/gfx/drivers_shader/shader_glsl.c
+++ b/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)
diff --git a/gfx/drivers_shader/shader_vulkan.cpp b/gfx/drivers_shader/shader_vulkan.cpp
index c8201f624b..b4f8abe2c0 100644
--- a/gfx/drivers_shader/shader_vulkan.cpp
+++ b/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);
diff --git a/gfx/drivers_shader/slang_process.cpp b/gfx/drivers_shader/slang_process.cpp
index 7768f9cfa3..c491d87122 100644
--- a/gfx/drivers_shader/slang_process.cpp
+++ b/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;
diff --git a/gfx/video_shader_parse.c b/gfx/video_shader_parse.c
index 9f1ed88095..29820bc574 100644
--- a/gfx/video_shader_parse.c
+++ b/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
diff --git a/gfx/video_shader_parse.h b/gfx/video_shader_parse.h
index 888e7736fe..e1defe8b8f 100644
--- a/gfx/video_shader_parse.h
+++ b/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;
 };
 
 
diff --git a/menu/cbs/menu_cbs_left.c b/menu/cbs/menu_cbs_left.c
index a7303651ff..e07a3bcc44 100644
--- a/menu/cbs/menu_cbs_left.c
+++ b/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;
 }
diff --git a/menu/cbs/menu_cbs_ok.c b/menu/cbs/menu_cbs_ok.c
index dfb5176c03..000a8df5d3 100644
--- a/menu/cbs/menu_cbs_ok.c
+++ b/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
diff --git a/menu/cbs/menu_cbs_right.c b/menu/cbs/menu_cbs_right.c
index 1b6b34beb7..16f47e6ce1 100644
--- a/menu/cbs/menu_cbs_right.c
+++ b/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;
 }
diff --git a/menu/menu_driver.c b/menu/menu_driver.c
index 67183a7df6..022d020cc7 100644
--- a/menu/menu_driver.c
+++ b/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
    {
diff --git a/menu/menu_setting.c b/menu/menu_setting.c
index bbbef89bd5..47f2b41e4d 100644
--- a/menu/menu_setting.c
+++ b/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);
diff --git a/ui/drivers/qt/qt_dialogs.cpp b/ui/drivers/qt/qt_dialogs.cpp
index 48d83a92f8..a641b70cf8 100644
--- a/ui/drivers/qt/qt_dialogs.cpp
+++ b/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;
       }
    }
 }