summaryrefslogtreecommitdiffstats
path: root/src/shell-blur-effect.c
diff options
context:
space:
mode:
authorDaniel Baumann <daniel.baumann@progress-linux.org>2024-04-07 17:54:43 +0000
committerDaniel Baumann <daniel.baumann@progress-linux.org>2024-04-07 17:54:43 +0000
commite4283f6d48b98e764b988b43bbc86b9d52e6ec94 (patch)
treec8f7f7a6c2f5faa2942d27cefc6fd46cca492656 /src/shell-blur-effect.c
parentInitial commit. (diff)
downloadgnome-shell-e4283f6d48b98e764b988b43bbc86b9d52e6ec94.tar.xz
gnome-shell-e4283f6d48b98e764b988b43bbc86b9d52e6ec94.zip
Adding upstream version 43.9.upstream/43.9upstream
Signed-off-by: Daniel Baumann <daniel.baumann@progress-linux.org>
Diffstat (limited to '')
-rw-r--r--src/shell-blur-effect.c907
1 files changed, 907 insertions, 0 deletions
diff --git a/src/shell-blur-effect.c b/src/shell-blur-effect.c
new file mode 100644
index 0000000..0d4bb45
--- /dev/null
+++ b/src/shell-blur-effect.c
@@ -0,0 +1,907 @@
+/* shell-blur-effect.c
+ *
+ * Copyright 2019 Georges Basile Stavracas Neto <georges.stavracas@gmail.com>
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program. If not, see <http://www.gnu.org/licenses/>.
+ *
+ * SPDX-License-Identifier: GPL-3.0-or-later
+ */
+
+#include "shell-blur-effect.h"
+
+#include "shell-enum-types.h"
+
+/**
+ * SECTION:shell-blur-effect
+ * @short_description: Blur effect for actors
+ *
+ * #ShellBlurEffect is a blur implementation based on Clutter. It also has
+ * an optional brightness property.
+ *
+ * # Modes
+ *
+ * #ShellBlurEffect can work in @SHELL_BLUR_MODE_BACKGROUND and @SHELL_BLUR_MODE_ACTOR
+ * modes. The actor mode blurs the actor itself, and all of its children. The
+ * background mode blurs the pixels beneath the actor, but not the actor itself.
+ *
+ * @SHELL_BLUR_MODE_BACKGROUND can be computationally expensive, since the contents
+ * beneath the actor cannot be cached, so beware of the performance implications
+ * of using this blur mode.
+ */
+
+static const gchar *brightness_glsl_declarations =
+"uniform float brightness; \n";
+
+static const gchar *brightness_glsl =
+" cogl_color_out.rgb *= brightness; \n";
+
+#define MIN_DOWNSCALE_SIZE 256.f
+#define MAX_SIGMA 6.f
+
+typedef enum
+{
+ ACTOR_PAINTED = 1 << 0,
+ BLUR_APPLIED = 1 << 1,
+} CacheFlags;
+
+typedef struct
+{
+ CoglFramebuffer *framebuffer;
+ CoglPipeline *pipeline;
+ CoglTexture *texture;
+} FramebufferData;
+
+struct _ShellBlurEffect
+{
+ ClutterEffect parent_instance;
+
+ ClutterActor *actor;
+
+ unsigned int tex_width;
+ unsigned int tex_height;
+
+ /* The cached contents */
+ FramebufferData actor_fb;
+ CacheFlags cache_flags;
+
+ FramebufferData background_fb;
+ FramebufferData brightness_fb;
+ int brightness_uniform;
+
+ ShellBlurMode mode;
+ float downscale_factor;
+ float brightness;
+ int sigma;
+};
+
+G_DEFINE_TYPE (ShellBlurEffect, shell_blur_effect, CLUTTER_TYPE_EFFECT)
+
+enum {
+ PROP_0,
+ PROP_SIGMA,
+ PROP_BRIGHTNESS,
+ PROP_MODE,
+ N_PROPS
+};
+
+static GParamSpec *properties [N_PROPS] = { NULL, };
+
+static CoglPipeline*
+create_base_pipeline (void)
+{
+ static CoglPipeline *base_pipeline = NULL;
+
+ if (G_UNLIKELY (base_pipeline == NULL))
+ {
+ CoglContext *ctx =
+ clutter_backend_get_cogl_context (clutter_get_default_backend ());
+
+ base_pipeline = cogl_pipeline_new (ctx);
+ cogl_pipeline_set_layer_null_texture (base_pipeline, 0);
+ cogl_pipeline_set_layer_filters (base_pipeline,
+ 0,
+ COGL_PIPELINE_FILTER_LINEAR,
+ COGL_PIPELINE_FILTER_LINEAR);
+ cogl_pipeline_set_layer_wrap_mode (base_pipeline,
+ 0,
+ COGL_PIPELINE_WRAP_MODE_CLAMP_TO_EDGE);
+ }
+
+ return cogl_pipeline_copy (base_pipeline);
+}
+
+static CoglPipeline*
+create_brightness_pipeline (void)
+{
+ static CoglPipeline *brightness_pipeline = NULL;
+
+ if (G_UNLIKELY (brightness_pipeline == NULL))
+ {
+ CoglSnippet *snippet;
+
+ brightness_pipeline = create_base_pipeline ();
+
+ snippet = cogl_snippet_new (COGL_SNIPPET_HOOK_FRAGMENT,
+ brightness_glsl_declarations,
+ brightness_glsl);
+ cogl_pipeline_add_snippet (brightness_pipeline, snippet);
+ cogl_object_unref (snippet);
+ }
+
+ return cogl_pipeline_copy (brightness_pipeline);
+}
+
+
+static void
+update_brightness (ShellBlurEffect *self,
+ uint8_t paint_opacity)
+{
+ cogl_pipeline_set_color4ub (self->brightness_fb.pipeline,
+ paint_opacity,
+ paint_opacity,
+ paint_opacity,
+ paint_opacity);
+
+ if (self->brightness_uniform > -1)
+ {
+ cogl_pipeline_set_uniform_1f (self->brightness_fb.pipeline,
+ self->brightness_uniform,
+ self->brightness);
+ }
+}
+
+static void
+setup_projection_matrix (CoglFramebuffer *framebuffer,
+ float width,
+ float height)
+{
+ graphene_matrix_t projection;
+
+ graphene_matrix_init_translate (&projection,
+ &GRAPHENE_POINT3D_INIT (-width / 2.0,
+ -height / 2.0,
+ 0.f));
+ graphene_matrix_scale (&projection, 2.0 / width, -2.0 / height, 1.f);
+
+ cogl_framebuffer_set_projection_matrix (framebuffer, &projection);
+}
+
+static gboolean
+update_fbo (FramebufferData *data,
+ unsigned int width,
+ unsigned int height,
+ float downscale_factor)
+{
+ CoglContext *ctx =
+ clutter_backend_get_cogl_context (clutter_get_default_backend ());
+
+ g_clear_pointer (&data->texture, cogl_object_unref);
+ g_clear_object (&data->framebuffer);
+
+ float new_width = floorf (width / downscale_factor);
+ float new_height = floorf (height / downscale_factor);
+
+ data->texture = cogl_texture_2d_new_with_size (ctx, new_width, new_height);
+ if (!data->texture)
+ return FALSE;
+
+ cogl_pipeline_set_layer_texture (data->pipeline, 0, data->texture);
+
+ data->framebuffer =
+ COGL_FRAMEBUFFER (cogl_offscreen_new_with_texture (data->texture));
+ if (!data->framebuffer)
+ {
+ g_warning ("%s: Unable to create an Offscreen buffer", G_STRLOC);
+ return FALSE;
+ }
+
+ setup_projection_matrix (data->framebuffer, new_width, new_height);
+
+ return TRUE;
+}
+
+static gboolean
+update_actor_fbo (ShellBlurEffect *self,
+ unsigned int width,
+ unsigned int height,
+ float downscale_factor)
+{
+ if (self->tex_width == width &&
+ self->tex_height == height &&
+ self->downscale_factor == downscale_factor &&
+ self->actor_fb.framebuffer)
+ {
+ return TRUE;
+ }
+
+ self->cache_flags &= ~ACTOR_PAINTED;
+
+ return update_fbo (&self->actor_fb, width, height, downscale_factor);
+}
+
+static gboolean
+update_brightness_fbo (ShellBlurEffect *self,
+ unsigned int width,
+ unsigned int height,
+ float downscale_factor)
+{
+ if (self->tex_width == width &&
+ self->tex_height == height &&
+ self->downscale_factor == downscale_factor &&
+ self->brightness_fb.framebuffer)
+ {
+ return TRUE;
+ }
+
+ return update_fbo (&self->brightness_fb,
+ width, height,
+ downscale_factor);
+}
+
+static gboolean
+update_background_fbo (ShellBlurEffect *self,
+ unsigned int width,
+ unsigned int height)
+{
+ if (self->tex_width == width &&
+ self->tex_height == height &&
+ self->background_fb.framebuffer)
+ {
+ return TRUE;
+ }
+
+ return update_fbo (&self->background_fb, width, height, 1.0);
+}
+
+static void
+clear_framebuffer_data (FramebufferData *fb_data)
+{
+ g_clear_pointer (&fb_data->texture, cogl_object_unref);
+ g_clear_object (&fb_data->framebuffer);
+}
+
+static float
+calculate_downscale_factor (float width,
+ float height,
+ float sigma)
+{
+ float downscale_factor = 1.0;
+ float scaled_width = width;
+ float scaled_height = height;
+ float scaled_sigma = sigma;
+
+ /* This is the algorithm used by Firefox; keep downscaling until either the
+ * blur radius is lower than the threshold, or the downscaled texture is too
+ * small.
+ */
+ while (scaled_sigma > MAX_SIGMA &&
+ scaled_width > MIN_DOWNSCALE_SIZE &&
+ scaled_height > MIN_DOWNSCALE_SIZE)
+ {
+ downscale_factor *= 2.f;
+
+ scaled_width = width / downscale_factor;
+ scaled_height = height / downscale_factor;
+ scaled_sigma = sigma / downscale_factor;
+ }
+
+ return downscale_factor;
+}
+
+static void
+shell_blur_effect_set_actor (ClutterActorMeta *meta,
+ ClutterActor *actor)
+{
+ ShellBlurEffect *self = SHELL_BLUR_EFFECT (meta);
+ ClutterActorMetaClass *meta_class;
+
+ meta_class = CLUTTER_ACTOR_META_CLASS (shell_blur_effect_parent_class);
+ meta_class->set_actor (meta, actor);
+
+ /* clear out the previous state */
+ clear_framebuffer_data (&self->actor_fb);
+ clear_framebuffer_data (&self->background_fb);
+ clear_framebuffer_data (&self->brightness_fb);
+
+ /* we keep a back pointer here, to avoid going through the ActorMeta */
+ self->actor = clutter_actor_meta_get_actor (meta);
+}
+
+static void
+update_actor_box (ShellBlurEffect *self,
+ ClutterPaintContext *paint_context,
+ ClutterActorBox *source_actor_box)
+{
+ ClutterStageView *stage_view;
+ float box_scale_factor = 1.0f;
+ float origin_x, origin_y;
+ float width, height;
+
+ switch (self->mode)
+ {
+ case SHELL_BLUR_MODE_ACTOR:
+ clutter_actor_get_allocation_box (self->actor, source_actor_box);
+ break;
+
+ case SHELL_BLUR_MODE_BACKGROUND:
+ stage_view = clutter_paint_context_get_stage_view (paint_context);
+
+ clutter_actor_get_transformed_position (self->actor, &origin_x, &origin_y);
+ clutter_actor_get_transformed_size (self->actor, &width, &height);
+
+ if (stage_view)
+ {
+ cairo_rectangle_int_t stage_view_layout;
+
+ box_scale_factor = clutter_stage_view_get_scale (stage_view);
+ clutter_stage_view_get_layout (stage_view, &stage_view_layout);
+
+ origin_x -= stage_view_layout.x;
+ origin_y -= stage_view_layout.y;
+ }
+ else
+ {
+ /* If we're drawing off stage, just assume scale = 1, this won't work
+ * with stage-view scaling though.
+ */
+ }
+
+ clutter_actor_box_set_origin (source_actor_box, origin_x, origin_y);
+ clutter_actor_box_set_size (source_actor_box, width, height);
+
+ clutter_actor_box_scale (source_actor_box, box_scale_factor);
+ break;
+ }
+
+ clutter_actor_box_clamp_to_pixel (source_actor_box);
+}
+
+static void
+add_blurred_pipeline (ShellBlurEffect *self,
+ ClutterPaintNode *node,
+ uint8_t paint_opacity)
+{
+ g_autoptr (ClutterPaintNode) pipeline_node = NULL;
+ float width, height;
+
+ /* Use the untransformed actor size here, since the framebuffer itself already
+ * has the actor transform matrix applied.
+ */
+ clutter_actor_get_size (self->actor, &width, &height);
+
+ update_brightness (self, paint_opacity);
+
+ pipeline_node = clutter_pipeline_node_new (self->brightness_fb.pipeline);
+ clutter_paint_node_set_static_name (pipeline_node, "ShellBlurEffect (final)");
+ clutter_paint_node_add_child (node, pipeline_node);
+
+ clutter_paint_node_add_rectangle (pipeline_node,
+ &(ClutterActorBox) {
+ 0.f, 0.f,
+ width,
+ height,
+ });
+}
+
+static ClutterPaintNode *
+create_blur_nodes (ShellBlurEffect *self,
+ ClutterPaintNode *node,
+ uint8_t paint_opacity)
+{
+ g_autoptr (ClutterPaintNode) brightness_node = NULL;
+ g_autoptr (ClutterPaintNode) blur_node = NULL;
+ float width;
+ float height;
+
+ clutter_actor_get_size (self->actor, &width, &height);
+
+ update_brightness (self, paint_opacity);
+ brightness_node = clutter_layer_node_new_to_framebuffer (self->brightness_fb.framebuffer,
+ self->brightness_fb.pipeline);
+ clutter_paint_node_set_static_name (brightness_node, "ShellBlurEffect (brightness)");
+ clutter_paint_node_add_child (node, brightness_node);
+ clutter_paint_node_add_rectangle (brightness_node,
+ &(ClutterActorBox) {
+ 0.f, 0.f,
+ width, height,
+ });
+
+ blur_node = clutter_blur_node_new (self->tex_width / self->downscale_factor,
+ self->tex_height / self->downscale_factor,
+ self->sigma / self->downscale_factor);
+ clutter_paint_node_set_static_name (blur_node, "ShellBlurEffect (blur)");
+ clutter_paint_node_add_child (brightness_node, blur_node);
+ clutter_paint_node_add_rectangle (blur_node,
+ &(ClutterActorBox) {
+ 0.f, 0.f,
+ cogl_texture_get_width (self->brightness_fb.texture),
+ cogl_texture_get_height (self->brightness_fb.texture),
+ });
+
+ self->cache_flags |= BLUR_APPLIED;
+
+ return g_steal_pointer (&blur_node);
+}
+
+static void
+paint_background (ShellBlurEffect *self,
+ ClutterPaintNode *node,
+ ClutterPaintContext *paint_context,
+ ClutterActorBox *source_actor_box)
+{
+ g_autoptr (ClutterPaintNode) background_node = NULL;
+ g_autoptr (ClutterPaintNode) blit_node = NULL;
+ CoglFramebuffer *src;
+ float transformed_x;
+ float transformed_y;
+ float transformed_width;
+ float transformed_height;
+
+ clutter_actor_box_get_origin (source_actor_box,
+ &transformed_x,
+ &transformed_y);
+ clutter_actor_box_get_size (source_actor_box,
+ &transformed_width,
+ &transformed_height);
+
+ /* Background layer node */
+ background_node =
+ clutter_layer_node_new_to_framebuffer (self->background_fb.framebuffer,
+ self->background_fb.pipeline);
+ clutter_paint_node_set_static_name (background_node, "ShellBlurEffect (background)");
+ clutter_paint_node_add_child (node, background_node);
+ clutter_paint_node_add_rectangle (background_node,
+ &(ClutterActorBox) {
+ 0.f, 0.f,
+ self->tex_width / self->downscale_factor,
+ self->tex_height / self->downscale_factor,
+ });
+
+ /* Blit node */
+ src = clutter_paint_context_get_framebuffer (paint_context);
+ blit_node = clutter_blit_node_new (src);
+ clutter_paint_node_set_static_name (blit_node, "ShellBlurEffect (blit)");
+ clutter_paint_node_add_child (background_node, blit_node);
+ clutter_blit_node_add_blit_rectangle (CLUTTER_BLIT_NODE (blit_node),
+ transformed_x,
+ transformed_y,
+ 0, 0,
+ transformed_width,
+ transformed_height);
+}
+
+static gboolean
+update_framebuffers (ShellBlurEffect *self,
+ ClutterPaintContext *paint_context,
+ ClutterActorBox *source_actor_box)
+{
+ gboolean updated = FALSE;
+ float downscale_factor;
+ float height = -1;
+ float width = -1;
+
+ clutter_actor_box_get_size (source_actor_box, &width, &height);
+
+ downscale_factor = calculate_downscale_factor (width, height, self->sigma);
+
+ updated = update_actor_fbo (self, width, height, downscale_factor) &&
+ update_brightness_fbo (self, width, height, downscale_factor);
+
+ if (self->mode == SHELL_BLUR_MODE_BACKGROUND)
+ updated = updated && update_background_fbo (self, width, height);
+
+ self->tex_width = width;
+ self->tex_height = height;
+ self->downscale_factor = downscale_factor;
+
+ return updated;
+}
+
+static void
+add_actor_node (ShellBlurEffect *self,
+ ClutterPaintNode *node,
+ int opacity)
+{
+ g_autoptr (ClutterPaintNode) actor_node = NULL;
+
+ actor_node = clutter_actor_node_new (self->actor, opacity);
+ clutter_paint_node_add_child (node, actor_node);
+}
+
+static void
+paint_actor_offscreen (ShellBlurEffect *self,
+ ClutterPaintNode *node,
+ ClutterEffectPaintFlags flags)
+{
+ gboolean actor_dirty;
+
+ actor_dirty = (flags & CLUTTER_EFFECT_PAINT_ACTOR_DIRTY) != 0;
+
+ /* The actor offscreen framebuffer is updated already */
+ if (actor_dirty || !(self->cache_flags & ACTOR_PAINTED))
+ {
+ g_autoptr (ClutterPaintNode) transform_node = NULL;
+ g_autoptr (ClutterPaintNode) layer_node = NULL;
+ graphene_matrix_t transform;
+
+ /* Layer node */
+ layer_node = clutter_layer_node_new_to_framebuffer (self->actor_fb.framebuffer,
+ self->actor_fb.pipeline);
+ clutter_paint_node_set_static_name (layer_node, "ShellBlurEffect (actor offscreen)");
+ clutter_paint_node_add_child (node, layer_node);
+ clutter_paint_node_add_rectangle (layer_node,
+ &(ClutterActorBox) {
+ 0.f, 0.f,
+ self->tex_width / self->downscale_factor,
+ self->tex_height / self->downscale_factor,
+ });
+
+ /* Transform node */
+ graphene_matrix_init_scale (&transform,
+ 1.f / self->downscale_factor,
+ 1.f / self->downscale_factor,
+ 1.f);
+ transform_node = clutter_transform_node_new (&transform);
+ clutter_paint_node_set_static_name (transform_node, "ShellBlurEffect (downscale)");
+ clutter_paint_node_add_child (layer_node, transform_node);
+
+ /* Actor node */
+ add_actor_node (self, transform_node, 255);
+
+ self->cache_flags |= ACTOR_PAINTED;
+ }
+ else
+ {
+ g_autoptr (ClutterPaintNode) pipeline_node = NULL;
+
+ pipeline_node = clutter_pipeline_node_new (self->actor_fb.pipeline);
+ clutter_paint_node_set_static_name (pipeline_node,
+ "ShellBlurEffect (actor texture)");
+ clutter_paint_node_add_child (node, pipeline_node);
+ clutter_paint_node_add_rectangle (pipeline_node,
+ &(ClutterActorBox) {
+ 0.f, 0.f,
+ self->tex_width / self->downscale_factor,
+ self->tex_height / self->downscale_factor,
+ });
+ }
+}
+
+static gboolean
+needs_repaint (ShellBlurEffect *self,
+ ClutterEffectPaintFlags flags)
+{
+ gboolean actor_cached;
+ gboolean blur_cached;
+ gboolean actor_dirty;
+
+ actor_dirty = (flags & CLUTTER_EFFECT_PAINT_ACTOR_DIRTY) != 0;
+ blur_cached = (self->cache_flags & BLUR_APPLIED) != 0;
+ actor_cached = (self->cache_flags & ACTOR_PAINTED) != 0;
+
+ switch (self->mode)
+ {
+ case SHELL_BLUR_MODE_ACTOR:
+ return actor_dirty || !blur_cached || !actor_cached;
+
+ case SHELL_BLUR_MODE_BACKGROUND:
+ return TRUE;
+ }
+
+ return TRUE;
+}
+
+static void
+shell_blur_effect_paint_node (ClutterEffect *effect,
+ ClutterPaintNode *node,
+ ClutterPaintContext *paint_context,
+ ClutterEffectPaintFlags flags)
+{
+ ShellBlurEffect *self = SHELL_BLUR_EFFECT (effect);
+ uint8_t paint_opacity;
+
+ g_assert (self->actor != NULL);
+
+ if (self->sigma > 0)
+ {
+ g_autoptr (ClutterPaintNode) blur_node = NULL;
+
+ switch (self->mode)
+ {
+ case SHELL_BLUR_MODE_ACTOR:
+ paint_opacity = clutter_actor_get_paint_opacity (self->actor);
+ break;
+
+ case SHELL_BLUR_MODE_BACKGROUND:
+ paint_opacity = 255;
+ break;
+
+ default:
+ g_assert_not_reached();
+ break;
+ }
+
+ if (needs_repaint (self, flags))
+ {
+ ClutterActorBox source_actor_box;
+
+ update_actor_box (self, paint_context, &source_actor_box);
+
+ /* Failing to create or update the offscreen framebuffers prevents
+ * the entire effect to be applied.
+ */
+ if (!update_framebuffers (self, paint_context, &source_actor_box))
+ goto fail;
+
+ blur_node = create_blur_nodes (self, node, paint_opacity);
+
+ switch (self->mode)
+ {
+ case SHELL_BLUR_MODE_ACTOR:
+ paint_actor_offscreen (self, blur_node, flags);
+ break;
+
+ case SHELL_BLUR_MODE_BACKGROUND:
+ paint_background (self, blur_node, paint_context, &source_actor_box);
+ break;
+ }
+ }
+ else
+ {
+ /* Use the cached pipeline if no repaint is needed */
+ add_blurred_pipeline (self, node, paint_opacity);
+ }
+
+ /* Background blur needs to paint the actor after painting the blurred
+ * background.
+ */
+ switch (self->mode)
+ {
+ case SHELL_BLUR_MODE_ACTOR:
+ break;
+
+ case SHELL_BLUR_MODE_BACKGROUND:
+ add_actor_node (self, node, -1);
+ break;
+ }
+
+ return;
+ }
+
+fail:
+ /* When no blur is applied, or the offscreen framebuffers
+ * couldn't be created, fallback to simply painting the actor.
+ */
+ add_actor_node (self, node, -1);
+}
+
+static void
+shell_blur_effect_finalize (GObject *object)
+{
+ ShellBlurEffect *self = (ShellBlurEffect *)object;
+
+ clear_framebuffer_data (&self->actor_fb);
+ clear_framebuffer_data (&self->background_fb);
+ clear_framebuffer_data (&self->brightness_fb);
+
+ g_clear_pointer (&self->actor_fb.pipeline, cogl_object_unref);
+ g_clear_pointer (&self->background_fb.pipeline, cogl_object_unref);
+ g_clear_pointer (&self->brightness_fb.pipeline, cogl_object_unref);
+
+ G_OBJECT_CLASS (shell_blur_effect_parent_class)->finalize (object);
+}
+
+static void
+shell_blur_effect_get_property (GObject *object,
+ guint prop_id,
+ GValue *value,
+ GParamSpec *pspec)
+{
+ ShellBlurEffect *self = SHELL_BLUR_EFFECT (object);
+
+ switch (prop_id)
+ {
+ case PROP_SIGMA:
+ g_value_set_int (value, self->sigma);
+ break;
+
+ case PROP_BRIGHTNESS:
+ g_value_set_float (value, self->brightness);
+ break;
+
+ case PROP_MODE:
+ g_value_set_enum (value, self->mode);
+ break;
+
+ default:
+ G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
+ }
+}
+
+static void
+shell_blur_effect_set_property (GObject *object,
+ guint prop_id,
+ const GValue *value,
+ GParamSpec *pspec)
+{
+ ShellBlurEffect *self = SHELL_BLUR_EFFECT (object);
+
+ switch (prop_id)
+ {
+ case PROP_SIGMA:
+ shell_blur_effect_set_sigma (self, g_value_get_int (value));
+ break;
+
+ case PROP_BRIGHTNESS:
+ shell_blur_effect_set_brightness (self, g_value_get_float (value));
+ break;
+
+ case PROP_MODE:
+ shell_blur_effect_set_mode (self, g_value_get_enum (value));
+ break;
+
+ default:
+ G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
+ }
+}
+
+static void
+shell_blur_effect_class_init (ShellBlurEffectClass *klass)
+{
+ GObjectClass *object_class = G_OBJECT_CLASS (klass);
+ ClutterActorMetaClass *meta_class = CLUTTER_ACTOR_META_CLASS (klass);
+ ClutterEffectClass *effect_class = CLUTTER_EFFECT_CLASS (klass);
+
+ object_class->finalize = shell_blur_effect_finalize;
+ object_class->get_property = shell_blur_effect_get_property;
+ object_class->set_property = shell_blur_effect_set_property;
+
+ meta_class->set_actor = shell_blur_effect_set_actor;
+
+ effect_class->paint_node = shell_blur_effect_paint_node;
+
+ properties[PROP_SIGMA] =
+ g_param_spec_int ("sigma",
+ "Sigma",
+ "Sigma",
+ 0, G_MAXINT, 0,
+ G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS | G_PARAM_EXPLICIT_NOTIFY);
+
+ properties[PROP_BRIGHTNESS] =
+ g_param_spec_float ("brightness",
+ "Brightness",
+ "Brightness",
+ 0.f, 1.f, 1.f,
+ G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS | G_PARAM_EXPLICIT_NOTIFY);
+
+ properties[PROP_MODE] =
+ g_param_spec_enum ("mode",
+ "Blur mode",
+ "Blur mode",
+ SHELL_TYPE_BLUR_MODE,
+ SHELL_BLUR_MODE_ACTOR,
+ G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS | G_PARAM_EXPLICIT_NOTIFY);
+
+ g_object_class_install_properties (object_class, N_PROPS, properties);
+}
+
+static void
+shell_blur_effect_init (ShellBlurEffect *self)
+{
+ self->mode = SHELL_BLUR_MODE_ACTOR;
+ self->sigma = 0;
+ self->brightness = 1.f;
+
+ self->actor_fb.pipeline = create_base_pipeline ();
+ self->background_fb.pipeline = create_base_pipeline ();
+ self->brightness_fb.pipeline = create_brightness_pipeline ();
+ self->brightness_uniform =
+ cogl_pipeline_get_uniform_location (self->brightness_fb.pipeline, "brightness");
+}
+
+ShellBlurEffect *
+shell_blur_effect_new (void)
+{
+ return g_object_new (SHELL_TYPE_BLUR_EFFECT, NULL);
+}
+
+int
+shell_blur_effect_get_sigma (ShellBlurEffect *self)
+{
+ g_return_val_if_fail (SHELL_IS_BLUR_EFFECT (self), -1);
+
+ return self->sigma;
+}
+
+void
+shell_blur_effect_set_sigma (ShellBlurEffect *self,
+ int sigma)
+{
+ g_return_if_fail (SHELL_IS_BLUR_EFFECT (self));
+
+ if (self->sigma == sigma)
+ return;
+
+ self->sigma = sigma;
+ self->cache_flags &= ~BLUR_APPLIED;
+
+ if (self->actor)
+ clutter_effect_queue_repaint (CLUTTER_EFFECT (self));
+
+ g_object_notify_by_pspec (G_OBJECT (self), properties[PROP_SIGMA]);
+}
+
+float
+shell_blur_effect_get_brightness (ShellBlurEffect *self)
+{
+ g_return_val_if_fail (SHELL_IS_BLUR_EFFECT (self), FALSE);
+
+ return self->brightness;
+}
+
+void
+shell_blur_effect_set_brightness (ShellBlurEffect *self,
+ float brightness)
+{
+ g_return_if_fail (SHELL_IS_BLUR_EFFECT (self));
+
+ if (self->brightness == brightness)
+ return;
+
+ self->brightness = brightness;
+ self->cache_flags &= ~BLUR_APPLIED;
+
+ if (self->actor)
+ clutter_effect_queue_repaint (CLUTTER_EFFECT (self));
+
+ g_object_notify_by_pspec (G_OBJECT (self), properties[PROP_BRIGHTNESS]);
+}
+
+ShellBlurMode
+shell_blur_effect_get_mode (ShellBlurEffect *self)
+{
+ g_return_val_if_fail (SHELL_IS_BLUR_EFFECT (self), -1);
+
+ return self->mode;
+}
+
+void
+shell_blur_effect_set_mode (ShellBlurEffect *self,
+ ShellBlurMode mode)
+{
+ g_return_if_fail (SHELL_IS_BLUR_EFFECT (self));
+
+ if (self->mode == mode)
+ return;
+
+ self->mode = mode;
+ self->cache_flags &= ~BLUR_APPLIED;
+
+ switch (mode)
+ {
+ case SHELL_BLUR_MODE_ACTOR:
+ clear_framebuffer_data (&self->background_fb);
+ break;
+
+ case SHELL_BLUR_MODE_BACKGROUND:
+ default:
+ /* Do nothing */
+ break;
+ }
+
+ if (self->actor)
+ clutter_effect_queue_repaint (CLUTTER_EFFECT (self));
+
+ g_object_notify_by_pspec (G_OBJECT (self), properties[PROP_MODE]);
+}