brl/mutter
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity
5e005b4298
mutter/clutter/clutter-blur-effect.c

279 lines
8.2 KiB
C
Raw Normal View History

effect: Add BlurEffect A simple, GLSL shader-based blur effect. The blur shader is taken straight from the test-shader.c interactive test case. It's a fairly clunky, inefficient and visually incorrect implementation of a box blur, but it's all we have right now until I figure out a way to do multi-pass shading with the current API.
2010-04-08 13:46:54 -04:00
/*
* Clutter.
*
* An OpenGL based 'interactive canvas' library.
*
* Copyright (C) 2010 Intel Corporation.
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
* License as published by the Free Software Foundation; either
* version 2 of the License, or (at your option) any later version.
*
* This library 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
* Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public
* License along with this library. If not, see <http://www.gnu.org/licenses/>.
*
* Author:
* Emmanuele Bassi <ebassi@linux.intel.com>
*/
/**
* SECTION:clutter-blur-effect
* @short_description: A blur effect
* @see_also: #ClutterEffect, #ClutterOffscreenEffect
*
* #ClutterBlurEffect is a sub-class of #ClutterEffect that allows blurring a
* actor and its contents.
*
* #ClutterBlurEffect is available since Clutter 1.4
*/
#define CLUTTER_BLUR_EFFECT_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), CLUTTER_TYPE_BLUR_EFFECT, ClutterBlurEffectClass))
#define CLUTTER_IS_BLUR_EFFECT_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), CLUTTER_TYPE_BLUR_EFFECT))
#define CLUTTER_BLUR_EFFECT_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), CLUTTER_TYPE_BLUR_EFFECT, ClutterBlurEffectClass))
#ifdef HAVE_CONFIG_H
#include "config.h"
#endif
Pass a CoglContext when calling cogl_pipeline_new The experimental cogl_pipeline_new() api was recently changed so it explicitly takes a CoglContext. This updates all calls to cogl_pipeline_new() in clutter accordingly.
2012-02-21 08:22:17 -05:00
#define CLUTTER_ENABLE_EXPERIMENTAL_API
effect: Add BlurEffect A simple, GLSL shader-based blur effect. The blur shader is taken straight from the test-shader.c interactive test case. It's a fairly clunky, inefficient and visually incorrect implementation of a box blur, but it's all we have right now until I figure out a way to do multi-pass shading with the current API.
2010-04-08 13:46:54 -04:00
#include "clutter-blur-effect.h"
#include "cogl/cogl.h"
#include "clutter-debug.h"
blur-effect: Do not inherit from ShaderEffect We might want to switch the BlurEffect from a box-blur to a super-sampling of the texture target, in order to make it cheap(er). If we inherit from ShaderEffect, though, we're setting in stone the fact that we are going to use a fragment shader for blurring. Since there is not parametrization of the blur, the code necessary to implement effect is pretty small, and we can use the Cogl API directly.
2010-08-11 08:05:42 -04:00
#include "clutter-offscreen-effect.h"
effect: Add BlurEffect A simple, GLSL shader-based blur effect. The blur shader is taken straight from the test-shader.c interactive test case. It's a fairly clunky, inefficient and visually incorrect implementation of a box blur, but it's all we have right now until I figure out a way to do multi-pass shading with the current API.
2010-04-08 13:46:54 -04:00
#include "clutter-private.h"
blur-effect: Add padding to account for the blur The blur effect will sample pixels on the edges of the offscreen buffer, so we want to add a padding to avoid clamping the blur. We do this by creating a larger target texture, and updating the paint volume of the actor during paint to take that padding into account.
2010-08-19 09:06:52 -04:00
#define BLUR_PADDING 2
effect: Add BlurEffect A simple, GLSL shader-based blur effect. The blur shader is taken straight from the test-shader.c interactive test case. It's a fairly clunky, inefficient and visually incorrect implementation of a box blur, but it's all we have right now until I figure out a way to do multi-pass shading with the current API.
2010-04-08 13:46:54 -04:00
/* FIXME - lame shader; we should really have a decoupled
* horizontal/vertical two pass shader for the gaussian blur
*/
Convert all of the internal shader-based effects to use snippets This converts the blur, colorize and desaturate effects to use snippets instead of CoglPrograms. Cogl can handle the snippets much more efficiently than programs so this should be a performance win. It also fixes the problem that Cogl would end up recompiling the program for every instance of the effects because Clutter was not reusing the same program. Reviewed-by: Emmanuele Bassi <ebassi@linux.intel.com>
2011-11-28 08:46:30 -05:00
static const gchar *box_blur_glsl_declarations =
"uniform vec2 pixel_step;\n";
#define SAMPLE(offx, offy) \
"cogl_texel += texture2D (cogl_sampler, cogl_tex_coord.st + pixel_step * " \
blur-effect: Fix the blur filter Make sure we don't sample the center twice, and don't sample things that aren't our immediate neighbors. https://bugzilla.gnome.org/show_bug.cgi?id=683076
2012-08-30 20:02:38 -04:00
"vec2 (" G_STRINGIFY (offx) ", " G_STRINGIFY (offy) "));\n"
effect: Add BlurEffect A simple, GLSL shader-based blur effect. The blur shader is taken straight from the test-shader.c interactive test case. It's a fairly clunky, inefficient and visually incorrect implementation of a box blur, but it's all we have right now until I figure out a way to do multi-pass shading with the current API.
2010-04-08 13:46:54 -04:00
static const gchar *box_blur_glsl_shader =
Convert all of the internal shader-based effects to use snippets This converts the blur, colorize and desaturate effects to use snippets instead of CoglPrograms. Cogl can handle the snippets much more efficiently than programs so this should be a performance win. It also fixes the problem that Cogl would end up recompiling the program for every instance of the effects because Clutter was not reusing the same program. Reviewed-by: Emmanuele Bassi <ebassi@linux.intel.com>
2011-11-28 08:46:30 -05:00
" cogl_texel = texture2D (cogl_sampler, cogl_tex_coord.st);\n"
SAMPLE (-1.0, -1.0)
SAMPLE ( 0.0, -1.0)
SAMPLE (+1.0, -1.0)
SAMPLE (-1.0, 0.0)
SAMPLE (+1.0, 0.0)
SAMPLE (-1.0, +1.0)
SAMPLE ( 0.0, +1.0)
SAMPLE (+1.0, +1.0)
" cogl_texel /= 9.0;\n";
#undef SAMPLE
effect: Add BlurEffect A simple, GLSL shader-based blur effect. The blur shader is taken straight from the test-shader.c interactive test case. It's a fairly clunky, inefficient and visually incorrect implementation of a box blur, but it's all we have right now until I figure out a way to do multi-pass shading with the current API.
2010-04-08 13:46:54 -04:00
struct _ClutterBlurEffect
{
blur-effect: Do not inherit from ShaderEffect We might want to switch the BlurEffect from a box-blur to a super-sampling of the texture target, in order to make it cheap(er). If we inherit from ShaderEffect, though, we're setting in stone the fact that we are going to use a fragment shader for blurring. Since there is not parametrization of the blur, the code necessary to implement effect is pretty small, and we can use the Cogl API directly.
2010-08-11 08:05:42 -04:00
ClutterOffscreenEffect parent_instance;
effect: Add BlurEffect A simple, GLSL shader-based blur effect. The blur shader is taken straight from the test-shader.c interactive test case. It's a fairly clunky, inefficient and visually incorrect implementation of a box blur, but it's all we have right now until I figure out a way to do multi-pass shading with the current API.
2010-04-08 13:46:54 -04:00
/* a back pointer to our actor, so that we can query it */
ClutterActor *actor;
Convert all of the internal shader-based effects to use snippets This converts the blur, colorize and desaturate effects to use snippets instead of CoglPrograms. Cogl can handle the snippets much more efficiently than programs so this should be a performance win. It also fixes the problem that Cogl would end up recompiling the program for every instance of the effects because Clutter was not reusing the same program. Reviewed-by: Emmanuele Bassi <ebassi@linux.intel.com>
2011-11-28 08:46:30 -05:00
gint pixel_step_uniform;
blur-effect: Do not inherit from ShaderEffect We might want to switch the BlurEffect from a box-blur to a super-sampling of the texture target, in order to make it cheap(er). If we inherit from ShaderEffect, though, we're setting in stone the fact that we are going to use a fragment shader for blurring. Since there is not parametrization of the blur, the code necessary to implement effect is pretty small, and we can use the Cogl API directly.
2010-08-11 08:05:42 -04:00
Convert all of the internal shader-based effects to use snippets This converts the blur, colorize and desaturate effects to use snippets instead of CoglPrograms. Cogl can handle the snippets much more efficiently than programs so this should be a performance win. It also fixes the problem that Cogl would end up recompiling the program for every instance of the effects because Clutter was not reusing the same program. Reviewed-by: Emmanuele Bassi <ebassi@linux.intel.com>
2011-11-28 08:46:30 -05:00
gint tex_width;
gint tex_height;
blur-effect: Do not inherit from ShaderEffect We might want to switch the BlurEffect from a box-blur to a super-sampling of the texture target, in order to make it cheap(er). If we inherit from ShaderEffect, though, we're setting in stone the fact that we are going to use a fragment shader for blurring. Since there is not parametrization of the blur, the code necessary to implement effect is pretty small, and we can use the Cogl API directly.
2010-08-11 08:05:42 -04:00
Convert all of the internal shader-based effects to use snippets This converts the blur, colorize and desaturate effects to use snippets instead of CoglPrograms. Cogl can handle the snippets much more efficiently than programs so this should be a performance win. It also fixes the problem that Cogl would end up recompiling the program for every instance of the effects because Clutter was not reusing the same program. Reviewed-by: Emmanuele Bassi <ebassi@linux.intel.com>
2011-11-28 08:46:30 -05:00
CoglPipeline *pipeline;
effect: Add BlurEffect A simple, GLSL shader-based blur effect. The blur shader is taken straight from the test-shader.c interactive test case. It's a fairly clunky, inefficient and visually incorrect implementation of a box blur, but it's all we have right now until I figure out a way to do multi-pass shading with the current API.
2010-04-08 13:46:54 -04:00
};
blur-effect: Do not inherit from ShaderEffect We might want to switch the BlurEffect from a box-blur to a super-sampling of the texture target, in order to make it cheap(er). If we inherit from ShaderEffect, though, we're setting in stone the fact that we are going to use a fragment shader for blurring. Since there is not parametrization of the blur, the code necessary to implement effect is pretty small, and we can use the Cogl API directly.
2010-08-11 08:05:42 -04:00
struct _ClutterBlurEffectClass
effect: Add BlurEffect A simple, GLSL shader-based blur effect. The blur shader is taken straight from the test-shader.c interactive test case. It's a fairly clunky, inefficient and visually incorrect implementation of a box blur, but it's all we have right now until I figure out a way to do multi-pass shading with the current API.
2010-04-08 13:46:54 -04:00
{
blur-effect: Do not inherit from ShaderEffect We might want to switch the BlurEffect from a box-blur to a super-sampling of the texture target, in order to make it cheap(er). If we inherit from ShaderEffect, though, we're setting in stone the fact that we are going to use a fragment shader for blurring. Since there is not parametrization of the blur, the code necessary to implement effect is pretty small, and we can use the Cogl API directly.
2010-08-11 08:05:42 -04:00
ClutterOffscreenEffectClass parent_class;
Convert all of the internal shader-based effects to use snippets This converts the blur, colorize and desaturate effects to use snippets instead of CoglPrograms. Cogl can handle the snippets much more efficiently than programs so this should be a performance win. It also fixes the problem that Cogl would end up recompiling the program for every instance of the effects because Clutter was not reusing the same program. Reviewed-by: Emmanuele Bassi <ebassi@linux.intel.com>
2011-11-28 08:46:30 -05:00
CoglPipeline *base_pipeline;
effect: Add BlurEffect A simple, GLSL shader-based blur effect. The blur shader is taken straight from the test-shader.c interactive test case. It's a fairly clunky, inefficient and visually incorrect implementation of a box blur, but it's all we have right now until I figure out a way to do multi-pass shading with the current API.
2010-04-08 13:46:54 -04:00
};
G_DEFINE_TYPE (ClutterBlurEffect,
clutter_blur_effect,
blur-effect: Do not inherit from ShaderEffect We might want to switch the BlurEffect from a box-blur to a super-sampling of the texture target, in order to make it cheap(er). If we inherit from ShaderEffect, though, we're setting in stone the fact that we are going to use a fragment shader for blurring. Since there is not parametrization of the blur, the code necessary to implement effect is pretty small, and we can use the Cogl API directly.
2010-08-11 08:05:42 -04:00
CLUTTER_TYPE_OFFSCREEN_EFFECT);
effect: Add BlurEffect A simple, GLSL shader-based blur effect. The blur shader is taken straight from the test-shader.c interactive test case. It's a fairly clunky, inefficient and visually incorrect implementation of a box blur, but it's all we have right now until I figure out a way to do multi-pass shading with the current API.
2010-04-08 13:46:54 -04:00
static gboolean
clutter_blur_effect_pre_paint (ClutterEffect *effect)
{
ClutterBlurEffect *self = CLUTTER_BLUR_EFFECT (effect);
ClutterEffectClass *parent_class;
if (!clutter_actor_meta_get_enabled (CLUTTER_ACTOR_META (effect)))
return FALSE;
self->actor = clutter_actor_meta_get_actor (CLUTTER_ACTOR_META (effect));
if (self->actor == NULL)
return FALSE;
effects: Check before using the cogl_shader_* API Since BlurEffect and DesaturateEffect are using the shader API implicitly and not using ClutterShaderEffect, we need to check if the underlying GL implementation supports the GLSL shading language and warn if not.
2010-08-11 12:25:17 -04:00
if (!clutter_feature_available (CLUTTER_FEATURE_SHADERS_GLSL))
{
/* if we don't have support for GLSL shaders then we
* forcibly disable the ActorMeta
*/
g_warning ("Unable to use the ShaderEffect: the graphics hardware "
"or the current GL driver does not implement support "
"for the GLSL shading language.");
clutter_actor_meta_set_enabled (CLUTTER_ACTOR_META (effect), FALSE);
return FALSE;
}
Convert all of the internal shader-based effects to use snippets This converts the blur, colorize and desaturate effects to use snippets instead of CoglPrograms. Cogl can handle the snippets much more efficiently than programs so this should be a performance win. It also fixes the problem that Cogl would end up recompiling the program for every instance of the effects because Clutter was not reusing the same program. Reviewed-by: Emmanuele Bassi <ebassi@linux.intel.com>
2011-11-28 08:46:30 -05:00
parent_class = CLUTTER_EFFECT_CLASS (clutter_blur_effect_parent_class);
if (parent_class->pre_paint (effect))
blur-effect: Do not inherit from ShaderEffect We might want to switch the BlurEffect from a box-blur to a super-sampling of the texture target, in order to make it cheap(er). If we inherit from ShaderEffect, though, we're setting in stone the fact that we are going to use a fragment shader for blurring. Since there is not parametrization of the blur, the code necessary to implement effect is pretty small, and we can use the Cogl API directly.
2010-08-11 08:05:42 -04:00
{
Convert all of the internal shader-based effects to use snippets This converts the blur, colorize and desaturate effects to use snippets instead of CoglPrograms. Cogl can handle the snippets much more efficiently than programs so this should be a performance win. It also fixes the problem that Cogl would end up recompiling the program for every instance of the effects because Clutter was not reusing the same program. Reviewed-by: Emmanuele Bassi <ebassi@linux.intel.com>
2011-11-28 08:46:30 -05:00
ClutterOffscreenEffect *offscreen_effect =
CLUTTER_OFFSCREEN_EFFECT (effect);
CoglHandle texture;
effect: Add BlurEffect A simple, GLSL shader-based blur effect. The blur shader is taken straight from the test-shader.c interactive test case. It's a fairly clunky, inefficient and visually incorrect implementation of a box blur, but it's all we have right now until I figure out a way to do multi-pass shading with the current API.
2010-04-08 13:46:54 -04:00
Convert all of the internal shader-based effects to use snippets This converts the blur, colorize and desaturate effects to use snippets instead of CoglPrograms. Cogl can handle the snippets much more efficiently than programs so this should be a performance win. It also fixes the problem that Cogl would end up recompiling the program for every instance of the effects because Clutter was not reusing the same program. Reviewed-by: Emmanuele Bassi <ebassi@linux.intel.com>
2011-11-28 08:46:30 -05:00
texture = clutter_offscreen_effect_get_texture (offscreen_effect);
self->tex_width = cogl_texture_get_width (texture);
self->tex_height = cogl_texture_get_height (texture);
blur-effect: Do not inherit from ShaderEffect We might want to switch the BlurEffect from a box-blur to a super-sampling of the texture target, in order to make it cheap(er). If we inherit from ShaderEffect, though, we're setting in stone the fact that we are going to use a fragment shader for blurring. Since there is not parametrization of the blur, the code necessary to implement effect is pretty small, and we can use the Cogl API directly.
2010-08-11 08:05:42 -04:00
Convert all of the internal shader-based effects to use snippets This converts the blur, colorize and desaturate effects to use snippets instead of CoglPrograms. Cogl can handle the snippets much more efficiently than programs so this should be a performance win. It also fixes the problem that Cogl would end up recompiling the program for every instance of the effects because Clutter was not reusing the same program. Reviewed-by: Emmanuele Bassi <ebassi@linux.intel.com>
2011-11-28 08:46:30 -05:00
if (self->pixel_step_uniform > -1)
blur-effect: Do not inherit from ShaderEffect We might want to switch the BlurEffect from a box-blur to a super-sampling of the texture target, in order to make it cheap(er). If we inherit from ShaderEffect, though, we're setting in stone the fact that we are going to use a fragment shader for blurring. Since there is not parametrization of the blur, the code necessary to implement effect is pretty small, and we can use the Cogl API directly.
2010-08-11 08:05:42 -04:00
{
Convert all of the internal shader-based effects to use snippets This converts the blur, colorize and desaturate effects to use snippets instead of CoglPrograms. Cogl can handle the snippets much more efficiently than programs so this should be a performance win. It also fixes the problem that Cogl would end up recompiling the program for every instance of the effects because Clutter was not reusing the same program. Reviewed-by: Emmanuele Bassi <ebassi@linux.intel.com>
2011-11-28 08:46:30 -05:00
gfloat pixel_step[2];
blur-effect: Do not inherit from ShaderEffect We might want to switch the BlurEffect from a box-blur to a super-sampling of the texture target, in order to make it cheap(er). If we inherit from ShaderEffect, though, we're setting in stone the fact that we are going to use a fragment shader for blurring. Since there is not parametrization of the blur, the code necessary to implement effect is pretty small, and we can use the Cogl API directly.
2010-08-11 08:05:42 -04:00
Convert all of the internal shader-based effects to use snippets This converts the blur, colorize and desaturate effects to use snippets instead of CoglPrograms. Cogl can handle the snippets much more efficiently than programs so this should be a performance win. It also fixes the problem that Cogl would end up recompiling the program for every instance of the effects because Clutter was not reusing the same program. Reviewed-by: Emmanuele Bassi <ebassi@linux.intel.com>
2011-11-28 08:46:30 -05:00
pixel_step[0] = 1.0f / self->tex_width;
pixel_step[1] = 1.0f / self->tex_height;
blur-effect: Do not inherit from ShaderEffect We might want to switch the BlurEffect from a box-blur to a super-sampling of the texture target, in order to make it cheap(er). If we inherit from ShaderEffect, though, we're setting in stone the fact that we are going to use a fragment shader for blurring. Since there is not parametrization of the blur, the code necessary to implement effect is pretty small, and we can use the Cogl API directly.
2010-08-11 08:05:42 -04:00
Convert all of the internal shader-based effects to use snippets This converts the blur, colorize and desaturate effects to use snippets instead of CoglPrograms. Cogl can handle the snippets much more efficiently than programs so this should be a performance win. It also fixes the problem that Cogl would end up recompiling the program for every instance of the effects because Clutter was not reusing the same program. Reviewed-by: Emmanuele Bassi <ebassi@linux.intel.com>
2011-11-28 08:46:30 -05:00
cogl_pipeline_set_uniform_float (self->pipeline,
self->pixel_step_uniform,
2, /* n_components */
1, /* count */
pixel_step);
blur-effect: Do not inherit from ShaderEffect We might want to switch the BlurEffect from a box-blur to a super-sampling of the texture target, in order to make it cheap(er). If we inherit from ShaderEffect, though, we're setting in stone the fact that we are going to use a fragment shader for blurring. Since there is not parametrization of the blur, the code necessary to implement effect is pretty small, and we can use the Cogl API directly.
2010-08-11 08:05:42 -04:00
}
Convert all of the internal shader-based effects to use snippets This converts the blur, colorize and desaturate effects to use snippets instead of CoglPrograms. Cogl can handle the snippets much more efficiently than programs so this should be a performance win. It also fixes the problem that Cogl would end up recompiling the program for every instance of the effects because Clutter was not reusing the same program. Reviewed-by: Emmanuele Bassi <ebassi@linux.intel.com>
2011-11-28 08:46:30 -05:00
cogl_pipeline_set_layer_texture (self->pipeline, 0, texture);
blur-effect: Do not inherit from ShaderEffect We might want to switch the BlurEffect from a box-blur to a super-sampling of the texture target, in order to make it cheap(er). If we inherit from ShaderEffect, though, we're setting in stone the fact that we are going to use a fragment shader for blurring. Since there is not parametrization of the blur, the code necessary to implement effect is pretty small, and we can use the Cogl API directly.
2010-08-11 08:05:42 -04:00
Convert all of the internal shader-based effects to use snippets This converts the blur, colorize and desaturate effects to use snippets instead of CoglPrograms. Cogl can handle the snippets much more efficiently than programs so this should be a performance win. It also fixes the problem that Cogl would end up recompiling the program for every instance of the effects because Clutter was not reusing the same program. Reviewed-by: Emmanuele Bassi <ebassi@linux.intel.com>
2011-11-28 08:46:30 -05:00
return TRUE;
blur-effect: Do not inherit from ShaderEffect We might want to switch the BlurEffect from a box-blur to a super-sampling of the texture target, in order to make it cheap(er). If we inherit from ShaderEffect, though, we're setting in stone the fact that we are going to use a fragment shader for blurring. Since there is not parametrization of the blur, the code necessary to implement effect is pretty small, and we can use the Cogl API directly.
2010-08-11 08:05:42 -04:00
}
Convert all of the internal shader-based effects to use snippets This converts the blur, colorize and desaturate effects to use snippets instead of CoglPrograms. Cogl can handle the snippets much more efficiently than programs so this should be a performance win. It also fixes the problem that Cogl would end up recompiling the program for every instance of the effects because Clutter was not reusing the same program. Reviewed-by: Emmanuele Bassi <ebassi@linux.intel.com>
2011-11-28 08:46:30 -05:00
else
return FALSE;
effect: Add BlurEffect A simple, GLSL shader-based blur effect. The blur shader is taken straight from the test-shader.c interactive test case. It's a fairly clunky, inefficient and visually incorrect implementation of a box blur, but it's all we have right now until I figure out a way to do multi-pass shading with the current API.
2010-04-08 13:46:54 -04:00
}
static void
blur-effect: Do not inherit from ShaderEffect We might want to switch the BlurEffect from a box-blur to a super-sampling of the texture target, in order to make it cheap(er). If we inherit from ShaderEffect, though, we're setting in stone the fact that we are going to use a fragment shader for blurring. Since there is not parametrization of the blur, the code necessary to implement effect is pretty small, and we can use the Cogl API directly.
2010-08-11 08:05:42 -04:00
clutter_blur_effect_paint_target (ClutterOffscreenEffect *effect)
effect: Add BlurEffect A simple, GLSL shader-based blur effect. The blur shader is taken straight from the test-shader.c interactive test case. It's a fairly clunky, inefficient and visually incorrect implementation of a box blur, but it's all we have right now until I figure out a way to do multi-pass shading with the current API.
2010-04-08 13:46:54 -04:00
{
blur-effect: Do not inherit from ShaderEffect We might want to switch the BlurEffect from a box-blur to a super-sampling of the texture target, in order to make it cheap(er). If we inherit from ShaderEffect, though, we're setting in stone the fact that we are going to use a fragment shader for blurring. Since there is not parametrization of the blur, the code necessary to implement effect is pretty small, and we can use the Cogl API directly.
2010-08-11 08:05:42 -04:00
ClutterBlurEffect *self = CLUTTER_BLUR_EFFECT (effect);
Convert all of the internal shader-based effects to use snippets This converts the blur, colorize and desaturate effects to use snippets instead of CoglPrograms. Cogl can handle the snippets much more efficiently than programs so this should be a performance win. It also fixes the problem that Cogl would end up recompiling the program for every instance of the effects because Clutter was not reusing the same program. Reviewed-by: Emmanuele Bassi <ebassi@linux.intel.com>
2011-11-28 08:46:30 -05:00
guint8 paint_opacity;
effect: Add BlurEffect A simple, GLSL shader-based blur effect. The blur shader is taken straight from the test-shader.c interactive test case. It's a fairly clunky, inefficient and visually incorrect implementation of a box blur, but it's all we have right now until I figure out a way to do multi-pass shading with the current API.
2010-04-08 13:46:54 -04:00
Convert all of the internal shader-based effects to use snippets This converts the blur, colorize and desaturate effects to use snippets instead of CoglPrograms. Cogl can handle the snippets much more efficiently than programs so this should be a performance win. It also fixes the problem that Cogl would end up recompiling the program for every instance of the effects because Clutter was not reusing the same program. Reviewed-by: Emmanuele Bassi <ebassi@linux.intel.com>
2011-11-28 08:46:30 -05:00
paint_opacity = clutter_actor_get_paint_opacity (self->actor);
blur-effect: Do not inherit from ShaderEffect We might want to switch the BlurEffect from a box-blur to a super-sampling of the texture target, in order to make it cheap(er). If we inherit from ShaderEffect, though, we're setting in stone the fact that we are going to use a fragment shader for blurring. Since there is not parametrization of the blur, the code necessary to implement effect is pretty small, and we can use the Cogl API directly.
2010-08-11 08:05:42 -04:00
Convert all of the internal shader-based effects to use snippets This converts the blur, colorize and desaturate effects to use snippets instead of CoglPrograms. Cogl can handle the snippets much more efficiently than programs so this should be a performance win. It also fixes the problem that Cogl would end up recompiling the program for every instance of the effects because Clutter was not reusing the same program. Reviewed-by: Emmanuele Bassi <ebassi@linux.intel.com>
2011-11-28 08:46:30 -05:00
cogl_pipeline_set_color4ub (self->pipeline,
paint_opacity,
paint_opacity,
paint_opacity,
paint_opacity);
cogl_push_source (self->pipeline);
blur-effect: Use the texture size to work out the x/y step The blur effect needs to pass a uniform to the GLSL shader so that it can know the texture coordinate offset from one texel to another. To calculate this the blur effect was previously using the allocation size of the actor rounded up to the next power of two. Presumably the assumption was that Cogl would round up the size of the texture to the next power of two when allocating the texture. However this is not be true if the driver supports NPOT textures. Also it doesn't take into account the paint volume of the actor which may cause the texture to be a completely different size. This patch just changes to directly use the size of the texture. Reviewed-by: Emmanuele Bassi <ebassi@linux.intel.com>
2012-02-13 10:11:44 -05:00
Convert all of the internal shader-based effects to use snippets This converts the blur, colorize and desaturate effects to use snippets instead of CoglPrograms. Cogl can handle the snippets much more efficiently than programs so this should be a performance win. It also fixes the problem that Cogl would end up recompiling the program for every instance of the effects because Clutter was not reusing the same program. Reviewed-by: Emmanuele Bassi <ebassi@linux.intel.com>
2011-11-28 08:46:30 -05:00
cogl_rectangle (0, 0, self->tex_width, self->tex_height);
blur-effect: Do not inherit from ShaderEffect We might want to switch the BlurEffect from a box-blur to a super-sampling of the texture target, in order to make it cheap(er). If we inherit from ShaderEffect, though, we're setting in stone the fact that we are going to use a fragment shader for blurring. Since there is not parametrization of the blur, the code necessary to implement effect is pretty small, and we can use the Cogl API directly.
2010-08-11 08:05:42 -04:00
Convert all of the internal shader-based effects to use snippets This converts the blur, colorize and desaturate effects to use snippets instead of CoglPrograms. Cogl can handle the snippets much more efficiently than programs so this should be a performance win. It also fixes the problem that Cogl would end up recompiling the program for every instance of the effects because Clutter was not reusing the same program. Reviewed-by: Emmanuele Bassi <ebassi@linux.intel.com>
2011-11-28 08:46:30 -05:00
cogl_pop_source ();
effect: Add BlurEffect A simple, GLSL shader-based blur effect. The blur shader is taken straight from the test-shader.c interactive test case. It's a fairly clunky, inefficient and visually incorrect implementation of a box blur, but it's all we have right now until I figure out a way to do multi-pass shading with the current API.
2010-04-08 13:46:54 -04:00
}
paint volumes: another pass at the design This is a fairly extensive second pass at exposing paint volumes for actors. The API has changed to allow clutter_actor_get_paint_volume to fail since there are times - such as when an actor isn't a descendent of the stage - when the volume can't be determined. Another example is when something has connected to the "paint" signal of the actor and we simply have no way of knowing what might be drawn in that handler. The API has also be changed to return a const ClutterPaintVolume pointer (transfer none) so we can avoid having to dynamically allocate the volumes in the most common/performance critical code paths. Profiling was showing the slice allocation of volumes taking about 1% of an apps time, for some fairly basic tests. Most volumes can now simply be allocated on the stack; for clutter_actor_get_paint_volume we return a pointer to &priv->paint_volume and if we need a more dynamic allocation there is now a _clutter_stage_paint_volume_stack_allocate() mechanism which lets us allocate data which expires at the start of the next frame. The API has been extended to make it easier to implement get_paint_volume for containers by using clutter_actor_get_transformed_paint_volume and clutter_paint_volume_union. The first allows you to query the paint volume of a child but transformed into parent actor coordinates. The second lets you combine volumes together so you can union all the volumes for a container's children and report that as the container's own volume. The representation of paint volumes has been updated to consider that 2D actors are the most common. The effect apis, clutter-texture and clutter-group have been update accordingly.
2010-09-07 13:04:19 -04:00
static gboolean
blur-effect: Add padding to account for the blur The blur effect will sample pixels on the edges of the offscreen buffer, so we want to add a padding to avoid clamping the blur. We do this by creating a larger target texture, and updating the paint volume of the actor during paint to take that padding into account.
2010-08-19 09:06:52 -04:00
clutter_blur_effect_get_paint_volume (ClutterEffect *effect,
ClutterPaintVolume *volume)
{
gfloat cur_width, cur_height;
ClutterVertex origin;
clutter_paint_volume_get_origin (volume, &origin);
cur_width = clutter_paint_volume_get_width (volume);
cur_height = clutter_paint_volume_get_height (volume);
origin.x -= BLUR_PADDING;
origin.y -= BLUR_PADDING;
blur-effect: fix paint volume padding For the blur effect we use a BLUR_PADDING constant to pad out the volume of the source actor on the x and y axis. Previously we were offsetting the origin negatively using BLUR_PADDING and then adding BLUR_PADDING to the width and height, but we should have been adding 2*BLUR_PADDING instead.
2010-09-07 14:07:19 -04:00
cur_width += 2 * BLUR_PADDING;
cur_height += 2 * BLUR_PADDING;
blur-effect: Add padding to account for the blur The blur effect will sample pixels on the edges of the offscreen buffer, so we want to add a padding to avoid clamping the blur. We do this by creating a larger target texture, and updating the paint volume of the actor during paint to take that padding into account.
2010-08-19 09:06:52 -04:00
clutter_paint_volume_set_origin (volume, &origin);
clutter_paint_volume_set_width (volume, cur_width);
clutter_paint_volume_set_height (volume, cur_height);
paint volumes: another pass at the design This is a fairly extensive second pass at exposing paint volumes for actors. The API has changed to allow clutter_actor_get_paint_volume to fail since there are times - such as when an actor isn't a descendent of the stage - when the volume can't be determined. Another example is when something has connected to the "paint" signal of the actor and we simply have no way of knowing what might be drawn in that handler. The API has also be changed to return a const ClutterPaintVolume pointer (transfer none) so we can avoid having to dynamically allocate the volumes in the most common/performance critical code paths. Profiling was showing the slice allocation of volumes taking about 1% of an apps time, for some fairly basic tests. Most volumes can now simply be allocated on the stack; for clutter_actor_get_paint_volume we return a pointer to &priv->paint_volume and if we need a more dynamic allocation there is now a _clutter_stage_paint_volume_stack_allocate() mechanism which lets us allocate data which expires at the start of the next frame. The API has been extended to make it easier to implement get_paint_volume for containers by using clutter_actor_get_transformed_paint_volume and clutter_paint_volume_union. The first allows you to query the paint volume of a child but transformed into parent actor coordinates. The second lets you combine volumes together so you can union all the volumes for a container's children and report that as the container's own volume. The representation of paint volumes has been updated to consider that 2D actors are the most common. The effect apis, clutter-texture and clutter-group have been update accordingly.
2010-09-07 13:04:19 -04:00
return TRUE;
blur-effect: Add padding to account for the blur The blur effect will sample pixels on the edges of the offscreen buffer, so we want to add a padding to avoid clamping the blur. We do this by creating a larger target texture, and updating the paint volume of the actor during paint to take that padding into account.
2010-08-19 09:06:52 -04:00
}
effect: Add BlurEffect A simple, GLSL shader-based blur effect. The blur shader is taken straight from the test-shader.c interactive test case. It's a fairly clunky, inefficient and visually incorrect implementation of a box blur, but it's all we have right now until I figure out a way to do multi-pass shading with the current API.
2010-04-08 13:46:54 -04:00
static void
blur-effect: Do not inherit from ShaderEffect We might want to switch the BlurEffect from a box-blur to a super-sampling of the texture target, in order to make it cheap(er). If we inherit from ShaderEffect, though, we're setting in stone the fact that we are going to use a fragment shader for blurring. Since there is not parametrization of the blur, the code necessary to implement effect is pretty small, and we can use the Cogl API directly.
2010-08-11 08:05:42 -04:00
clutter_blur_effect_dispose (GObject *gobject)
effect: Add BlurEffect A simple, GLSL shader-based blur effect. The blur shader is taken straight from the test-shader.c interactive test case. It's a fairly clunky, inefficient and visually incorrect implementation of a box blur, but it's all we have right now until I figure out a way to do multi-pass shading with the current API.
2010-04-08 13:46:54 -04:00
{
blur-effect: Do not inherit from ShaderEffect We might want to switch the BlurEffect from a box-blur to a super-sampling of the texture target, in order to make it cheap(er). If we inherit from ShaderEffect, though, we're setting in stone the fact that we are going to use a fragment shader for blurring. Since there is not parametrization of the blur, the code necessary to implement effect is pretty small, and we can use the Cogl API directly.
2010-08-11 08:05:42 -04:00
ClutterBlurEffect *self = CLUTTER_BLUR_EFFECT (gobject);
Convert all of the internal shader-based effects to use snippets This converts the blur, colorize and desaturate effects to use snippets instead of CoglPrograms. Cogl can handle the snippets much more efficiently than programs so this should be a performance win. It also fixes the problem that Cogl would end up recompiling the program for every instance of the effects because Clutter was not reusing the same program. Reviewed-by: Emmanuele Bassi <ebassi@linux.intel.com>
2011-11-28 08:46:30 -05:00
if (self->pipeline != NULL)
effect: Add BlurEffect A simple, GLSL shader-based blur effect. The blur shader is taken straight from the test-shader.c interactive test case. It's a fairly clunky, inefficient and visually incorrect implementation of a box blur, but it's all we have right now until I figure out a way to do multi-pass shading with the current API.
2010-04-08 13:46:54 -04:00
{
Convert all of the internal shader-based effects to use snippets This converts the blur, colorize and desaturate effects to use snippets instead of CoglPrograms. Cogl can handle the snippets much more efficiently than programs so this should be a performance win. It also fixes the problem that Cogl would end up recompiling the program for every instance of the effects because Clutter was not reusing the same program. Reviewed-by: Emmanuele Bassi <ebassi@linux.intel.com>
2011-11-28 08:46:30 -05:00
cogl_object_unref (self->pipeline);
self->pipeline = NULL;
effect: Add BlurEffect A simple, GLSL shader-based blur effect. The blur shader is taken straight from the test-shader.c interactive test case. It's a fairly clunky, inefficient and visually incorrect implementation of a box blur, but it's all we have right now until I figure out a way to do multi-pass shading with the current API.
2010-04-08 13:46:54 -04:00
}
blur-effect: Do not inherit from ShaderEffect We might want to switch the BlurEffect from a box-blur to a super-sampling of the texture target, in order to make it cheap(er). If we inherit from ShaderEffect, though, we're setting in stone the fact that we are going to use a fragment shader for blurring. Since there is not parametrization of the blur, the code necessary to implement effect is pretty small, and we can use the Cogl API directly.
2010-08-11 08:05:42 -04:00
G_OBJECT_CLASS (clutter_blur_effect_parent_class)->dispose (gobject);
effect: Add BlurEffect A simple, GLSL shader-based blur effect. The blur shader is taken straight from the test-shader.c interactive test case. It's a fairly clunky, inefficient and visually incorrect implementation of a box blur, but it's all we have right now until I figure out a way to do multi-pass shading with the current API.
2010-04-08 13:46:54 -04:00
}
static void
clutter_blur_effect_class_init (ClutterBlurEffectClass *klass)
{
ClutterEffectClass *effect_class = CLUTTER_EFFECT_CLASS (klass);
GObjectClass *gobject_class = G_OBJECT_CLASS (klass);
blur-effect: Do not inherit from ShaderEffect We might want to switch the BlurEffect from a box-blur to a super-sampling of the texture target, in order to make it cheap(er). If we inherit from ShaderEffect, though, we're setting in stone the fact that we are going to use a fragment shader for blurring. Since there is not parametrization of the blur, the code necessary to implement effect is pretty small, and we can use the Cogl API directly.
2010-08-11 08:05:42 -04:00
ClutterOffscreenEffectClass *offscreen_class;
gobject_class->dispose = clutter_blur_effect_dispose;
effect: Add BlurEffect A simple, GLSL shader-based blur effect. The blur shader is taken straight from the test-shader.c interactive test case. It's a fairly clunky, inefficient and visually incorrect implementation of a box blur, but it's all we have right now until I figure out a way to do multi-pass shading with the current API.
2010-04-08 13:46:54 -04:00
effect_class->pre_paint = clutter_blur_effect_pre_paint;
blur-effect: Add padding to account for the blur The blur effect will sample pixels on the edges of the offscreen buffer, so we want to add a padding to avoid clamping the blur. We do this by creating a larger target texture, and updating the paint volume of the actor during paint to take that padding into account.
2010-08-19 09:06:52 -04:00
effect_class->get_paint_volume = clutter_blur_effect_get_paint_volume;
effect: Add BlurEffect A simple, GLSL shader-based blur effect. The blur shader is taken straight from the test-shader.c interactive test case. It's a fairly clunky, inefficient and visually incorrect implementation of a box blur, but it's all we have right now until I figure out a way to do multi-pass shading with the current API.
2010-04-08 13:46:54 -04:00
blur-effect: Do not inherit from ShaderEffect We might want to switch the BlurEffect from a box-blur to a super-sampling of the texture target, in order to make it cheap(er). If we inherit from ShaderEffect, though, we're setting in stone the fact that we are going to use a fragment shader for blurring. Since there is not parametrization of the blur, the code necessary to implement effect is pretty small, and we can use the Cogl API directly.
2010-08-11 08:05:42 -04:00
offscreen_class = CLUTTER_OFFSCREEN_EFFECT_CLASS (klass);
offscreen_class->paint_target = clutter_blur_effect_paint_target;
effect: Add BlurEffect A simple, GLSL shader-based blur effect. The blur shader is taken straight from the test-shader.c interactive test case. It's a fairly clunky, inefficient and visually incorrect implementation of a box blur, but it's all we have right now until I figure out a way to do multi-pass shading with the current API.
2010-04-08 13:46:54 -04:00
}
static void
clutter_blur_effect_init (ClutterBlurEffect *self)
{
effects: Delay the creation of the base pipeline Unconditionally creating CoglPipeline and CoglSnippets inside the class initialization functions does not seem to be enough when dealing with headless builds. Our last resort is to lazily create the base pipeline the first time we try to copy it, during the instance initialization.
2012-02-15 04:30:18 -05:00
ClutterBlurEffectClass *klass = CLUTTER_BLUR_EFFECT_GET_CLASS (self);
if (G_UNLIKELY (klass->base_pipeline == NULL))
{
CoglSnippet *snippet;
Pass a CoglContext when calling cogl_pipeline_new The experimental cogl_pipeline_new() api was recently changed so it explicitly takes a CoglContext. This updates all calls to cogl_pipeline_new() in clutter accordingly.
2012-02-21 08:22:17 -05:00
CoglContext *ctx =
clutter_backend_get_cogl_context (clutter_get_default_backend ());
effects: Delay the creation of the base pipeline Unconditionally creating CoglPipeline and CoglSnippets inside the class initialization functions does not seem to be enough when dealing with headless builds. Our last resort is to lazily create the base pipeline the first time we try to copy it, during the instance initialization.
2012-02-15 04:30:18 -05:00
Pass a CoglContext when calling cogl_pipeline_new The experimental cogl_pipeline_new() api was recently changed so it explicitly takes a CoglContext. This updates all calls to cogl_pipeline_new() in clutter accordingly.
2012-02-21 08:22:17 -05:00
klass->base_pipeline = cogl_pipeline_new (ctx);
effects: Delay the creation of the base pipeline Unconditionally creating CoglPipeline and CoglSnippets inside the class initialization functions does not seem to be enough when dealing with headless builds. Our last resort is to lazily create the base pipeline the first time we try to copy it, during the instance initialization.
2012-02-15 04:30:18 -05:00
snippet = cogl_snippet_new (COGL_SNIPPET_HOOK_TEXTURE_LOOKUP,
box_blur_glsl_declarations,
NULL);
cogl_snippet_set_replace (snippet, box_blur_glsl_shader);
cogl_pipeline_add_layer_snippet (klass->base_pipeline, 0, snippet);
cogl_object_unref (snippet);
cogl_pipeline_set_layer_null_texture (klass->base_pipeline,
0, /* layer number */
COGL_TEXTURE_TYPE_2D);
}
Convert all of the internal shader-based effects to use snippets This converts the blur, colorize and desaturate effects to use snippets instead of CoglPrograms. Cogl can handle the snippets much more efficiently than programs so this should be a performance win. It also fixes the problem that Cogl would end up recompiling the program for every instance of the effects because Clutter was not reusing the same program. Reviewed-by: Emmanuele Bassi <ebassi@linux.intel.com>
2011-11-28 08:46:30 -05:00
effects: Delay the creation of the base pipeline Unconditionally creating CoglPipeline and CoglSnippets inside the class initialization functions does not seem to be enough when dealing with headless builds. Our last resort is to lazily create the base pipeline the first time we try to copy it, during the instance initialization.
2012-02-15 04:30:18 -05:00
self->pipeline = cogl_pipeline_copy (klass->base_pipeline);
Convert all of the internal shader-based effects to use snippets This converts the blur, colorize and desaturate effects to use snippets instead of CoglPrograms. Cogl can handle the snippets much more efficiently than programs so this should be a performance win. It also fixes the problem that Cogl would end up recompiling the program for every instance of the effects because Clutter was not reusing the same program. Reviewed-by: Emmanuele Bassi <ebassi@linux.intel.com>
2011-11-28 08:46:30 -05:00
self->pixel_step_uniform =
cogl_pipeline_get_uniform_location (self->pipeline, "pixel_step");
effect: Add BlurEffect A simple, GLSL shader-based blur effect. The blur shader is taken straight from the test-shader.c interactive test case. It's a fairly clunky, inefficient and visually incorrect implementation of a box blur, but it's all we have right now until I figure out a way to do multi-pass shading with the current API.
2010-04-08 13:46:54 -04:00
}
/**
* clutter_blur_effect_new:
*
* Creates a new #ClutterBlurEffect to be used with
docs: Effects fixes for the API reference
2010-06-03 09:34:41 -04:00
* clutter_actor_add_effect()
effect: Add BlurEffect A simple, GLSL shader-based blur effect. The blur shader is taken straight from the test-shader.c interactive test case. It's a fairly clunky, inefficient and visually incorrect implementation of a box blur, but it's all we have right now until I figure out a way to do multi-pass shading with the current API.
2010-04-08 13:46:54 -04:00
*
* Return value: the newly created #ClutterBlurEffect or %NULL
*
* Since: 1.4
*/
ClutterEffect *
clutter_blur_effect_new (void)
{
return g_object_new (CLUTTER_TYPE_BLUR_EFFECT, NULL);
}
Reference in New Issue Copy Permalink