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

332 lines
9.7 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 17:46:54 +00: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
#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 12:05:42 +00: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 17:46:54 +00: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 13:06:52 +00: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 17:46:54 +00:00
typedef struct _ClutterBlurEffectClass ClutterBlurEffectClass;
/* FIXME - lame shader; we should really have a decoupled
* horizontal/vertical two pass shader for the gaussian blur
*/
static const gchar *box_blur_glsl_shader =
"uniform sampler2D tex;\n"
"uniform float x_step, y_step;\n"
"\n"
"vec4 get_rgba_rel (sampler2D source, float dx, float dy)\n"
"{\n"
cogl-shader: Prepend boilerplate for portable shaders We now prepend a set of defines to any given GLSL shader so that we can define builtin uniforms/attributes within the "cogl" namespace that we can use to provide compatibility across a range of the earlier versions of GLSL. This updates test-cogl-shader-glsl.c and test-shader.c so they no longer needs to special case GLES vs GL when splicing together its shaders as well as the blur, colorize and desaturate effects. To get a feel for the new, portable uniform/attribute names here are the defines for OpenGL vertex shaders: #define cogl_position_in gl_Vertex #define cogl_color_in gl_Color #define cogl_tex_coord_in gl_MultiTexCoord0 #define cogl_tex_coord0_in gl_MultiTexCoord0 #define cogl_tex_coord1_in gl_MultiTexCoord1 #define cogl_tex_coord2_in gl_MultiTexCoord2 #define cogl_tex_coord3_in gl_MultiTexCoord3 #define cogl_tex_coord4_in gl_MultiTexCoord4 #define cogl_tex_coord5_in gl_MultiTexCoord5 #define cogl_tex_coord6_in gl_MultiTexCoord6 #define cogl_tex_coord7_in gl_MultiTexCoord7 #define cogl_normal_in gl_Normal #define cogl_position_out gl_Position #define cogl_point_size_out gl_PointSize #define cogl_color_out gl_FrontColor #define cogl_tex_coord_out gl_TexCoord #define cogl_modelview_matrix gl_ModelViewMatrix #define cogl_modelview_projection_matrix gl_ModelViewProjectionMatrix #define cogl_projection_matrix gl_ProjectionMatrix #define cogl_texture_matrix gl_TextureMatrix And for fragment shaders we have: #define cogl_color_in gl_Color #define cogl_tex_coord_in gl_TexCoord #define cogl_color_out gl_FragColor #define cogl_depth_out gl_FragDepth #define cogl_front_facing gl_FrontFacing
2010-07-23 16:46:41 +00:00
" return texture2D (tex, cogl_tex_coord[0].st + vec2 (dx, dy) * 2.0);\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 17:46:54 +00:00
"}\n"
"\n"
"void main ()\n"
"{\n"
cogl-shader: Prepend boilerplate for portable shaders We now prepend a set of defines to any given GLSL shader so that we can define builtin uniforms/attributes within the "cogl" namespace that we can use to provide compatibility across a range of the earlier versions of GLSL. This updates test-cogl-shader-glsl.c and test-shader.c so they no longer needs to special case GLES vs GL when splicing together its shaders as well as the blur, colorize and desaturate effects. To get a feel for the new, portable uniform/attribute names here are the defines for OpenGL vertex shaders: #define cogl_position_in gl_Vertex #define cogl_color_in gl_Color #define cogl_tex_coord_in gl_MultiTexCoord0 #define cogl_tex_coord0_in gl_MultiTexCoord0 #define cogl_tex_coord1_in gl_MultiTexCoord1 #define cogl_tex_coord2_in gl_MultiTexCoord2 #define cogl_tex_coord3_in gl_MultiTexCoord3 #define cogl_tex_coord4_in gl_MultiTexCoord4 #define cogl_tex_coord5_in gl_MultiTexCoord5 #define cogl_tex_coord6_in gl_MultiTexCoord6 #define cogl_tex_coord7_in gl_MultiTexCoord7 #define cogl_normal_in gl_Normal #define cogl_position_out gl_Position #define cogl_point_size_out gl_PointSize #define cogl_color_out gl_FrontColor #define cogl_tex_coord_out gl_TexCoord #define cogl_modelview_matrix gl_ModelViewMatrix #define cogl_modelview_projection_matrix gl_ModelViewProjectionMatrix #define cogl_projection_matrix gl_ProjectionMatrix #define cogl_texture_matrix gl_TextureMatrix And for fragment shaders we have: #define cogl_color_in gl_Color #define cogl_tex_coord_in gl_TexCoord #define cogl_color_out gl_FragColor #define cogl_depth_out gl_FragDepth #define cogl_front_facing gl_FrontFacing
2010-07-23 16:46:41 +00:00
" vec4 color = cogl_color_in * texture2D (tex, vec2 (cogl_tex_coord[0].xy));\n"
effects: Make sure we're using GLSL 1.10
2010-09-21 12:32:31 +00:00
" color += get_rgba_rel (tex, -x_step, -y_step);\n"
" color += get_rgba_rel (tex, 0.0, -y_step);\n"
" color += get_rgba_rel (tex, x_step, -y_step);\n"
" color += get_rgba_rel (tex, -x_step, 0.0);\n"
" color += get_rgba_rel (tex, 0.0, 0.0);\n"
" color += get_rgba_rel (tex, x_step, 0.0);\n"
" color += get_rgba_rel (tex, -x_step, y_step);\n"
" color += get_rgba_rel (tex, 0.0, y_step);\n"
" color += get_rgba_rel (tex, x_step, y_step);\n"
cogl-shader: Prepend boilerplate for portable shaders We now prepend a set of defines to any given GLSL shader so that we can define builtin uniforms/attributes within the "cogl" namespace that we can use to provide compatibility across a range of the earlier versions of GLSL. This updates test-cogl-shader-glsl.c and test-shader.c so they no longer needs to special case GLES vs GL when splicing together its shaders as well as the blur, colorize and desaturate effects. To get a feel for the new, portable uniform/attribute names here are the defines for OpenGL vertex shaders: #define cogl_position_in gl_Vertex #define cogl_color_in gl_Color #define cogl_tex_coord_in gl_MultiTexCoord0 #define cogl_tex_coord0_in gl_MultiTexCoord0 #define cogl_tex_coord1_in gl_MultiTexCoord1 #define cogl_tex_coord2_in gl_MultiTexCoord2 #define cogl_tex_coord3_in gl_MultiTexCoord3 #define cogl_tex_coord4_in gl_MultiTexCoord4 #define cogl_tex_coord5_in gl_MultiTexCoord5 #define cogl_tex_coord6_in gl_MultiTexCoord6 #define cogl_tex_coord7_in gl_MultiTexCoord7 #define cogl_normal_in gl_Normal #define cogl_position_out gl_Position #define cogl_point_size_out gl_PointSize #define cogl_color_out gl_FrontColor #define cogl_tex_coord_out gl_TexCoord #define cogl_modelview_matrix gl_ModelViewMatrix #define cogl_modelview_projection_matrix gl_ModelViewProjectionMatrix #define cogl_projection_matrix gl_ProjectionMatrix #define cogl_texture_matrix gl_TextureMatrix And for fragment shaders we have: #define cogl_color_in gl_Color #define cogl_tex_coord_in gl_TexCoord #define cogl_color_out gl_FragColor #define cogl_depth_out gl_FragDepth #define cogl_front_facing gl_FrontFacing
2010-07-23 16:46:41 +00:00
" cogl_color_out = color / 9.0;\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 17:46:54 +00: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 12:05:42 +00: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 17:46:54 +00:00
/* a back pointer to our actor, so that we can query it */
ClutterActor *actor;
/* the parameters; x_step and y_step depend on
* the actor's allocation
*/
gfloat x_step;
gfloat y_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 12:05:42 +00:00
CoglHandle shader;
CoglHandle program;
gint tex_uniform;
gint x_step_uniform;
gint y_step_uniform;
guint is_compiled : 1;
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 17:46:54 +00: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 12:05:42 +00: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 17:46:54 +00: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 12:05:42 +00:00
ClutterOffscreenEffectClass parent_class;
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 17:46:54 +00: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 12:05:42 +00: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 17:46:54 +00:00
static int
next_p2 (int a)
{
int rval = 1;
while (rval < a)
rval <<= 1;
return rval;
}
static gboolean
clutter_blur_effect_pre_paint (ClutterEffect *effect)
{
ClutterBlurEffect *self = CLUTTER_BLUR_EFFECT (effect);
ClutterEffectClass *parent_class;
ClutterActorBox allocation;
gfloat width, height;
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 16:25:17 +00: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;
}
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 17:46:54 +00:00
clutter_actor_get_allocation_box (self->actor, &allocation);
clutter_actor_box_get_size (&allocation, &width, &height);
self->x_step = 1.0f / (float) next_p2 (width);
self->y_step = 1.0f / (float) next_p2 (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 12:05:42 +00:00
if (self->shader == COGL_INVALID_HANDLE)
{
self->shader = cogl_create_shader (COGL_SHADER_TYPE_FRAGMENT);
cogl_shader_source (self->shader, box_blur_glsl_shader);
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 17:46:54 +00: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 12:05:42 +00:00
self->is_compiled = FALSE;
self->tex_uniform = -1;
self->x_step_uniform = -1;
self->y_step_uniform = -1;
}
if (self->program == COGL_INVALID_HANDLE)
self->program = cogl_create_program ();
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 17:46:54 +00: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 12:05:42 +00:00
if (!self->is_compiled)
{
g_assert (self->shader != COGL_INVALID_HANDLE);
g_assert (self->program != COGL_INVALID_HANDLE);
cogl_shader_compile (self->shader);
if (!cogl_shader_is_compiled (self->shader))
{
gchar *log_buf = cogl_shader_get_info_log (self->shader);
g_warning (G_STRLOC ": Unable to compile the box blur shader: %s",
log_buf);
g_free (log_buf);
cogl_handle_unref (self->shader);
cogl_handle_unref (self->program);
self->shader = COGL_INVALID_HANDLE;
self->program = COGL_INVALID_HANDLE;
}
else
{
cogl_program_attach_shader (self->program, self->shader);
cogl_program_link (self->program);
cogl_handle_unref (self->shader);
self->is_compiled = TRUE;
self->tex_uniform =
cogl_program_get_uniform_location (self->program, "tex");
self->x_step_uniform =
cogl_program_get_uniform_location (self->program, "x_step");
self->y_step_uniform =
cogl_program_get_uniform_location (self->program, "y_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 17:46:54 +00:00
parent_class = CLUTTER_EFFECT_CLASS (clutter_blur_effect_parent_class);
return parent_class->pre_paint (effect);
}
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 13:06:52 +00:00
static CoglHandle
clutter_blur_effect_create_texture (ClutterOffscreenEffect *effect,
gfloat min_width,
gfloat min_height)
{
return cogl_texture_new_with_size (min_width + (2 * BLUR_PADDING),
min_height + (2 * BLUR_PADDING),
COGL_TEXTURE_NO_SLICING,
COGL_PIXEL_FORMAT_RGBA_8888_PRE);
}
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 17:46:54 +00: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 12:05:42 +00: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 17:46:54 +00: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 12:05:42 +00:00
ClutterBlurEffect *self = CLUTTER_BLUR_EFFECT (effect);
ClutterOffscreenEffectClass *parent;
CoglHandle material;
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 17:46:54 +00: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 12:05:42 +00:00
if (self->program == COGL_INVALID_HANDLE)
goto out;
if (self->tex_uniform > -1)
Remove last uses of cogl_program_uniform* Following the commits: c03544da - clutter-shader: use cogl_program_set_uniform_xyz API a26119b5 - tests: Remove use of cogl_program_use Remove the users of cogl_program_uniform_* and cogl_program_use() in the shader-based effects.
2010-08-12 16:06:29 +00:00
cogl_program_set_uniform_1i (self->program, self->tex_uniform, 0);
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 12:05:42 +00:00
if (self->x_step_uniform > -1)
Remove last uses of cogl_program_uniform* Following the commits: c03544da - clutter-shader: use cogl_program_set_uniform_xyz API a26119b5 - tests: Remove use of cogl_program_use Remove the users of cogl_program_uniform_* and cogl_program_use() in the shader-based effects.
2010-08-12 16:06:29 +00:00
cogl_program_set_uniform_1f (self->program,
self->x_step_uniform,
self->x_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 12:05:42 +00:00
if (self->y_step_uniform > -1)
Remove last uses of cogl_program_uniform* Following the commits: c03544da - clutter-shader: use cogl_program_set_uniform_xyz API a26119b5 - tests: Remove use of cogl_program_use Remove the users of cogl_program_uniform_* and cogl_program_use() in the shader-based effects.
2010-08-12 16:06:29 +00:00
cogl_program_set_uniform_1f (self->program,
self->y_step_uniform,
self->y_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 12:05:42 +00:00
material = clutter_offscreen_effect_get_target (effect);
cogl_material_set_user_program (material, self->program);
out:
parent = CLUTTER_OFFSCREEN_EFFECT_CLASS (clutter_blur_effect_parent_class);
parent->paint_target (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 17:46:54 +00: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 17:04:19 +00: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 13:06:52 +00: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 18:07:19 +00: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 13:06:52 +00: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 17:04:19 +00: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 13:06:52 +00: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 17:46:54 +00: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 12:05:42 +00: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 17:46:54 +00: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 12:05:42 +00:00
ClutterBlurEffect *self = CLUTTER_BLUR_EFFECT (gobject);
if (self->program != COGL_INVALID_HANDLE)
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 17:46:54 +00: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 12:05:42 +00:00
cogl_handle_unref (self->program);
self->program = COGL_INVALID_HANDLE;
self->shader = COGL_INVALID_HANDLE;
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 17:46:54 +00: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 12:05:42 +00: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 17:46:54 +00: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 12:05:42 +00: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 17:46:54 +00: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 13:06:52 +00: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 17:46:54 +00: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 12:05:42 +00:00
offscreen_class = CLUTTER_OFFSCREEN_EFFECT_CLASS (klass);
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 13:06:52 +00:00
offscreen_class->create_texture = clutter_blur_effect_create_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 12:05:42 +00:00
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 17:46:54 +00:00
}
static void
clutter_blur_effect_init (ClutterBlurEffect *self)
{
}
/**
* clutter_blur_effect_new:
*
* Creates a new #ClutterBlurEffect to be used with
docs: Effects fixes for the API reference
2010-06-03 13:34:41 +00: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 17:46:54 +00: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