static void
clutter_colorize_effect_class_init (ClutterColorizeEffectClass *klass)
{
ClutterEffectClass *effect_class = CLUTTER_EFFECT_CLASS (klass);
GObjectClass *gobject_class = G_OBJECT_CLASS (klass);
ClutterOffscreenEffectClass *offscreen_class;
offscreen_class = CLUTTER_OFFSCREEN_EFFECT_CLASS (klass);
offscreen_class->paint_target = clutter_colorize_effect_paint_target;
effect_class->pre_paint = clutter_colorize_effect_pre_paint;
gobject_class->set_property = clutter_colorize_effect_set_property;
gobject_class->get_property = clutter_colorize_effect_get_property;
gobject_class->dispose = clutter_colorize_effect_dispose;
/**
* ClutterColorizeEffect:tint:
*
* The tint to apply to the actor
*
* Since: 1.4
*/
obj_props[PROP_TINT] =
clutter_param_spec_color ("tint",
P_("Tint"),
P_("The tint to apply"),
&default_tint,
CLUTTER_PARAM_READWRITE);
g_object_class_install_properties (gobject_class, PROP_LAST, obj_props);
}
static void
mx_fade_effect_post_paint (ClutterEffect *effect)
{
MxFadeEffectPrivate *priv = MX_FADE_EFFECT (effect)->priv;
if (!priv->freeze_update)
CLUTTER_EFFECT_CLASS (mx_fade_effect_parent_class)->post_paint (effect);
else
{
CoglMatrix modelview;
ClutterActor *actor, *stage;
actor = clutter_actor_meta_get_actor (CLUTTER_ACTOR_META (effect));
stage = clutter_actor_get_stage (actor);
/* Set up the draw matrix so we draw the offscreen texture at the
* absolute coordinates of the actor-box. We need to do this to
* avoid transforming by the actor matrix twice, as when it's drawn
* into the offscreen surface, it'll already be transformed.
*/
cogl_push_matrix ();
cogl_matrix_init_identity (&modelview);
CLUTTER_ACTOR_CLASS (G_OBJECT_GET_CLASS (stage))->
apply_transform (stage, &modelview);
cogl_matrix_translate (&modelview, priv->x_offset, priv->y_offset, 0.f);
cogl_set_modelview_matrix (&modelview);
clutter_offscreen_effect_paint_target (CLUTTER_OFFSCREEN_EFFECT (effect));
cogl_pop_matrix ();
}
}
static void
st_scroll_view_fade_class_init (StScrollViewFadeClass *klass)
{
ClutterEffectClass *effect_class = CLUTTER_EFFECT_CLASS (klass);
GObjectClass *gobject_class = G_OBJECT_CLASS (klass);
ClutterOffscreenEffectClass *offscreen_class;
ClutterActorMetaClass *meta_class = CLUTTER_ACTOR_META_CLASS (klass);
gobject_class->dispose = st_scroll_view_fade_dispose;
gobject_class->get_property = st_scroll_view_fade_get_property;
gobject_class->set_property = st_scroll_view_fade_set_property;
meta_class->set_actor = st_scroll_view_fade_set_actor;
effect_class->pre_paint = st_scroll_view_fade_pre_paint;
offscreen_class = CLUTTER_OFFSCREEN_EFFECT_CLASS (klass);
offscreen_class->create_texture = st_scroll_view_fade_create_texture;
offscreen_class->paint_target = st_scroll_view_fade_paint_target;
g_object_class_install_property (gobject_class,
PROP_FADE_OFFSET,
g_param_spec_float ("fade-offset",
"Fade Offset",
"The height of the area which is faded at the edge",
0.f, G_MAXFLOAT, DEFAULT_FADE_OFFSET,
G_PARAM_READWRITE));
}
static void
clutter_desaturate_effect_class_init (ClutterDesaturateEffectClass *klass)
{
ClutterEffectClass *effect_class = CLUTTER_EFFECT_CLASS (klass);
GObjectClass *gobject_class = G_OBJECT_CLASS (klass);
ClutterOffscreenEffectClass *offscreen_class;
offscreen_class = CLUTTER_OFFSCREEN_EFFECT_CLASS (klass);
offscreen_class->paint_target = clutter_desaturate_effect_paint_target;
effect_class->pre_paint = clutter_desaturate_effect_pre_paint;
/**
* ClutterDesaturateEffect:factor:
*
* The desaturation factor, between 0.0 (no desaturation) and 1.0 (full
* desaturation).
*
* Since: 1.4
*/
obj_props[PROP_FACTOR] =
g_param_spec_double ("factor",
P_("Factor"),
P_("The desaturation factor"),
0.0, 1.0,
1.0,
CLUTTER_PARAM_READWRITE);
gobject_class->dispose = clutter_desaturate_effect_dispose;
gobject_class->set_property = clutter_desaturate_effect_set_property;
gobject_class->get_property = clutter_desaturate_effect_get_property;
g_object_class_install_properties (gobject_class, PROP_LAST, obj_props);
}
static void
empathy_rounded_effect_class_init (EmpathyRoundedEffectClass *klass)
{
ClutterEffectClass *effect_class = CLUTTER_EFFECT_CLASS (klass);
effect_class->paint = empathy_rounded_effect_paint;
}
static void
shader_paint (ClutterEffect *effect,
ClutterEffectPaintFlags flags)
{
ClutterShaderEffect *shader = CLUTTER_SHADER_EFFECT (effect);
float tex_width;
ClutterActor *actor =
clutter_actor_meta_get_actor (CLUTTER_ACTOR_META (effect));
if (g_test_verbose ())
g_debug ("shader_paint");
clutter_shader_effect_set_shader_source (shader,
"uniform sampler2D tex;\n"
"uniform float step;\n"
"void main (void)\n"
"{\n"
" gl_FragColor = texture2D(tex, vec2 (gl_TexCoord[0].s + step,\n"
" gl_TexCoord[0].t));\n"
"}\n");
tex_width = clutter_actor_get_width (actor);
clutter_shader_effect_set_uniform (shader, "tex", G_TYPE_INT, 1, 0);
clutter_shader_effect_set_uniform (shader, "step", G_TYPE_FLOAT, 1,
SHIFT_STEP / tex_width);
CLUTTER_EFFECT_CLASS (shift_effect_parent_class)->paint (effect, flags);
}
static gboolean
mx_fade_effect_pre_paint (ClutterEffect *effect)
{
MxFadeEffectPrivate *priv = MX_FADE_EFFECT (effect)->priv;
if (!priv->freeze_update)
{
return CLUTTER_EFFECT_CLASS (mx_fade_effect_parent_class)->
pre_paint (effect);
}
else
{
ClutterActorBox box;
ClutterActor *actor =
clutter_actor_meta_get_actor (CLUTTER_ACTOR_META (effect));
/* Store the stage coordinates of the actor for when we post-paint */
clutter_actor_get_paint_box (actor, &box);
clutter_actor_box_get_origin (&box, &priv->x_offset, &priv->y_offset);
/* Connect to the paint signal so we can block it */
priv->blocked_id =
g_signal_connect (actor, "paint",
G_CALLBACK (mx_fade_effect_paint_cb), effect);
return TRUE;
}
}
static void
shift_effect_class_init (ShiftEffectClass *klass)
{
ClutterEffectClass *shader_class = CLUTTER_EFFECT_CLASS (klass);
shader_class->paint = shader_paint;
shader_class->pick = shader_pick;
}
static void
shell_anamorphosis_effect_class_init (ShellAnamorphosisEffectClass *klass)
{
ClutterEffectClass *effect_class = CLUTTER_EFFECT_CLASS (klass);
ClutterOffscreenEffectClass *offscreen_class = CLUTTER_OFFSCREEN_EFFECT_CLASS (klass);
offscreen_class->paint_target = shell_anamorphosis_effect_paint_target;
effect_class->pre_paint = shell_anamorphosis_effect_pre_paint;
}
static gboolean
st_scroll_view_fade_pre_paint (ClutterEffect *effect)
{
StScrollViewFade *self = ST_SCROLL_VIEW_FADE (effect);
ClutterEffectClass *parent_class;
if (self->shader == COGL_INVALID_HANDLE)
return FALSE;
if (!clutter_actor_meta_get_enabled (CLUTTER_ACTOR_META (effect)))
return FALSE;
if (self->actor == NULL)
return FALSE;
if (self->program == COGL_INVALID_HANDLE)
self->program = cogl_create_program ();
if (!self->is_attached)
{
g_assert (self->shader != COGL_INVALID_HANDLE);
g_assert (self->program != COGL_INVALID_HANDLE);
cogl_program_attach_shader (self->program, self->shader);
cogl_program_link (self->program);
cogl_handle_unref (self->shader);
self->is_attached = TRUE;
self->tex_uniform =
cogl_program_get_uniform_location (self->program, "tex");
self->height_uniform =
cogl_program_get_uniform_location (self->program, "height");
self->width_uniform =
cogl_program_get_uniform_location (self->program, "width");
self->scrollbar_width_uniform =
cogl_program_get_uniform_location (self->program, "scrollbar_width");
self->scrollbar_height_uniform =
cogl_program_get_uniform_location (self->program, "scrollbar_height");
self->rtl_uniform =
cogl_program_get_uniform_location (self->program, "rtl");
self->offset_top_uniform =
cogl_program_get_uniform_location (self->program, "offset_top");
self->offset_bottom_uniform =
cogl_program_get_uniform_location (self->program, "offset_bottom");
}
parent_class = CLUTTER_EFFECT_CLASS (st_scroll_view_fade_parent_class);
return parent_class->pre_paint (effect);
}
static void
cd_icc_effect_class_init (CdIccEffectClass *klass)
{
ClutterEffectClass *effect_class = CLUTTER_EFFECT_CLASS (klass);
GObjectClass *gobject_class = G_OBJECT_CLASS (klass);
ClutterOffscreenEffectClass *offscreen_class;
gobject_class->dispose = cd_icc_effect_dispose;
effect_class->pre_paint = cd_icc_effect_pre_paint;
offscreen_class = CLUTTER_OFFSCREEN_EFFECT_CLASS (klass);
offscreen_class->paint_target = cd_icc_effect_paint_target;
}
static void
shell_grid_desaturate_effect_class_init (ShellGridDesaturateEffectClass *klass)
{
ClutterEffectClass *effect_class = CLUTTER_EFFECT_CLASS (klass);
GObjectClass *gobject_class = G_OBJECT_CLASS (klass);
ClutterOffscreenEffectClass *offscreen_class;
offscreen_class = CLUTTER_OFFSCREEN_EFFECT_CLASS (klass);
offscreen_class->paint_target = shell_grid_desaturate_effect_paint_target;
effect_class->pre_paint = shell_grid_desaturate_effect_pre_paint;
/**
* ShellGridDesaturateEffect:factor:
*
* The desaturation factor, between 0.0 (no desaturation) and 1.0 (full
* desaturation).
*/
obj_props[PROP_FACTOR] =
g_param_spec_double ("factor",
"Factor",
"The desaturation factor",
0.0, 1.0,
1.0,
G_PARAM_READWRITE);
/**
* ShellGridDesaturateEffect:unshaded-rect:
*
* The unshaded rectangle.
*/
obj_props[PROP_UNSHADED_RECT] =
g_param_spec_boxed ("unshaded-rect",
"Unshaded rect",
"The unshaded rectangle",
CLUTTER_TYPE_RECT,
G_PARAM_READWRITE);
gobject_class->dispose = shell_grid_desaturate_effect_dispose;
gobject_class->set_property = shell_grid_desaturate_effect_set_property;
gobject_class->get_property = shell_grid_desaturate_effect_get_property;
g_object_class_install_properties (gobject_class, PROP_LAST, obj_props);
}
static gboolean
shell_grid_desaturate_effect_pre_paint (ClutterEffect *effect)
{
ShellGridDesaturateEffect *self = SHELL_GRID_DESATURATE_EFFECT (effect);
ClutterEffectClass *parent_class;
if (!clutter_actor_meta_get_enabled (CLUTTER_ACTOR_META (effect)))
return FALSE;
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;
}
parent_class = CLUTTER_EFFECT_CLASS (shell_grid_desaturate_effect_parent_class);
if (parent_class->pre_paint (effect))
{
ClutterOffscreenEffect *offscreen_effect =
CLUTTER_OFFSCREEN_EFFECT (effect);
CoglHandle texture;
texture = clutter_offscreen_effect_get_texture (offscreen_effect);
self->tex_width = cogl_texture_get_width (texture);
self->tex_height = cogl_texture_get_height (texture);
if (self->unshaded_uniform_dirty)
update_unshaded_uniform (self);
cogl_pipeline_set_layer_texture (self->pipeline, 0, texture);
return TRUE;
}
else
return FALSE;
}
static gboolean
shell_anamorphosis_effect_pre_paint (ClutterEffect *effect)
{
ShellAnamorphosisEffect *self = SHELL_ANAMORPHOSIS_EFFECT (effect);
ShellAnamorphosisEffectPrivate *priv = shell_anamorphosis_effect_get_instance_private (self);
if (!clutter_actor_meta_get_enabled (CLUTTER_ACTOR_META (effect)))
return FALSE;
/* If we're not doing any bending, we're not needed. */
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 ShellAnamorphosisEffect: the "
"graphics hardware or the current GL driver does not "
"implement support for the GLSL shading language. The "
"effect will be disabled.");
clutter_actor_meta_set_enabled (CLUTTER_ACTOR_META (effect), FALSE);
return FALSE;
}
if (!CLUTTER_EFFECT_CLASS (shell_anamorphosis_effect_parent_class)->pre_paint (effect))
return FALSE;
ClutterOffscreenEffect *offscreen_effect = CLUTTER_OFFSCREEN_EFFECT (effect);
CoglObject *texture;
texture = clutter_offscreen_effect_get_texture (offscreen_effect);
cogl_pipeline_set_layer_texture (priv->pipeline, 0, texture);
priv->tex_width = cogl_texture_get_width (texture);
priv->tex_height = cogl_texture_get_height (texture);
cogl_pipeline_set_uniform_1i (priv->pipeline, priv->tex_width_uniform, priv->tex_width);
cogl_pipeline_set_uniform_1i (priv->pipeline, priv->tex_height_uniform, priv->tex_height);
return TRUE;
}
static void
st_background_effect_class_init (StBackgroundEffectClass *klass)
{
ClutterEffectClass *effect_class = CLUTTER_EFFECT_CLASS (klass);
GObjectClass *gobject_class = G_OBJECT_CLASS (klass);
ClutterOffscreenEffectClass *offscreen_class;
effect_class->pre_paint = st_background_effect_pre_paint;
gobject_class->set_property = st_background_effect_set_property;
gobject_class->get_property = st_background_effect_get_property;
gobject_class->dispose = st_background_effect_dispose;
offscreen_class = CLUTTER_OFFSCREEN_EFFECT_CLASS (klass);
offscreen_class->paint_target = st_background_effect_paint_target;
obj_props[PROP_BUMPMAP] =
g_param_spec_string ("bumpmap",
"Background effect construct prop",
"Set bumpmap path",
"/usr/share/cinnamon/bumpmaps/bumpmap.png",
G_PARAM_READWRITE);
g_object_class_install_properties (gobject_class, PROP_LAST, obj_props);
}
static void
mx_fade_effect_class_init (MxFadeEffectClass *klass)
{
GParamSpec *pspec;
ClutterColor transparent = { 0, };
GObjectClass *object_class = G_OBJECT_CLASS (klass);
ClutterEffectClass *effect_class = CLUTTER_EFFECT_CLASS (klass);
ClutterOffscreenEffectClass *offscreen_class =
CLUTTER_OFFSCREEN_EFFECT_CLASS (klass);
g_type_class_add_private (klass, sizeof (MxFadeEffectPrivate));
object_class->get_property = mx_fade_effect_get_property;
object_class->set_property = mx_fade_effect_set_property;
object_class->dispose = mx_fade_effect_dispose;
object_class->finalize = mx_fade_effect_finalize;
effect_class->pre_paint = mx_fade_effect_pre_paint;
effect_class->post_paint = mx_fade_effect_post_paint;
offscreen_class->create_texture = mx_fade_effect_create_texture;
offscreen_class->paint_target = mx_fade_effect_paint_target;
pspec = g_param_spec_int ("bounds-x",
"Bounds X",
"X-coordinate of the texture bounding box",
-G_MAXINT, G_MAXINT, 0,
MX_PARAM_READWRITE | MX_PARAM_TRANSLATEABLE);
g_object_class_install_property (object_class, PROP_BOUNDS_X, pspec);
pspec = g_param_spec_int ("bounds-y",
"Bounds Y",
"Y-coordinate of the texture bounding boy",
-G_MAXINT, G_MAXINT, 0,
MX_PARAM_READWRITE | MX_PARAM_TRANSLATEABLE);
g_object_class_install_property (object_class, PROP_BOUNDS_Y, pspec);
pspec = g_param_spec_uint ("bounds-width",
"Bounds width",
"Width of the texture bounding box",
0, G_MAXUINT, 0,
MX_PARAM_READWRITE | MX_PARAM_TRANSLATEABLE);
g_object_class_install_property (object_class, PROP_BOUNDS_WIDTH, pspec);
pspec = g_param_spec_uint ("bounds-height",
"Bounds height",
"Height of the texture bounding box",
0, G_MAXUINT, 0,
MX_PARAM_READWRITE | MX_PARAM_TRANSLATEABLE);
g_object_class_install_property (object_class, PROP_BOUNDS_HEIGHT, pspec);
pspec = g_param_spec_uint ("border-top",
"Border top",
"Border at the top of the effect",
0, G_MAXUINT, 0,
MX_PARAM_READWRITE | MX_PARAM_TRANSLATEABLE);
g_object_class_install_property (object_class, PROP_BORDER_TOP, pspec);
pspec = g_param_spec_uint ("border-right",
"Border right",
"Border at the right of the effect",
0, G_MAXUINT, 0,
MX_PARAM_READWRITE | MX_PARAM_TRANSLATEABLE);
g_object_class_install_property (object_class, PROP_BORDER_RIGHT, pspec);
pspec = g_param_spec_uint ("border-bottom",
"Border bottom",
"Border at the bottom of the effect",
0, G_MAXUINT, 0,
MX_PARAM_READWRITE | MX_PARAM_TRANSLATEABLE);
g_object_class_install_property (object_class, PROP_BORDER_BOTTOM, pspec);
pspec = g_param_spec_uint ("border-left",
"Border left",
"Border at the left of the effect",
0, G_MAXUINT, 0,
MX_PARAM_READWRITE | MX_PARAM_TRANSLATEABLE);
g_object_class_install_property (object_class, PROP_BORDER_LEFT, pspec);
pspec = clutter_param_spec_color ("color",
"Color",
"Color of the faded border",
&transparent,
MX_PARAM_READWRITE |
MX_PARAM_TRANSLATEABLE);
g_object_class_install_property (object_class, PROP_COLOR, pspec);
pspec = g_param_spec_boolean ("freeze-update",
"Freeze update",
"Stop updating the offscreen buffer",
FALSE,
MX_PARAM_READWRITE |
MX_PARAM_TRANSLATEABLE);
g_object_class_install_property (object_class, PROP_FREEZE_UPDATE, pspec);
}
static gboolean
cd_icc_effect_pre_paint (ClutterEffect *effect)
{
CdIccEffect *self = CD_ICC_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;
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;
}
clutter_actor_get_allocation_box (self->actor, &allocation);
clutter_actor_box_get_size (&allocation, &width, &height);
if (self->shader == COGL_INVALID_HANDLE)
{
self->shader = cogl_create_shader (COGL_SHADER_TYPE_FRAGMENT);
cogl_shader_source (self->shader, glsl_shader);
self->is_compiled = FALSE;
self->main_texture_uniform = -1;
self->indirect_texture_uniform = -1;
self->color_data1_uniform = -1;
self->color_data2_uniform = -1;
}
if (self->program == COGL_INVALID_HANDLE)
self->program = cogl_create_program ();
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 icc 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->main_texture_uniform =
cogl_program_get_uniform_location (self->program, "main_texture");
self->indirect_texture_uniform =
cogl_program_get_uniform_location (self->program, "indirect_texture");
self->color_data1_uniform =
cogl_program_get_uniform_location (self->program, "color_data1");
self->color_data2_uniform =
cogl_program_get_uniform_location (self->program, "color_data2");
}
}
parent_class = CLUTTER_EFFECT_CLASS (cd_icc_effect_parent_class);
return parent_class->pre_paint (effect);
}
static gboolean
st_background_effect_pre_paint (ClutterEffect *effect)
{
StBackgroundEffect *self = ST_BACKGROUND_EFFECT (effect);
ClutterEffectClass *parent_class;
gfloat width;
gfloat height;
gfloat posx;
gfloat posy;
guchar *data;
guint size;
guint rowstride;
glong new_time;
gdouble time_used;
ClutterActor *stage;
gfloat stage_width;
gfloat stage_height;
if (self->bg_bumpmap == NULL)
return FALSE;
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;
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;
}
new_time = clock();
time_used = ((double) (new_time - self->old_time)*100) / (double) CLOCKS_PER_SEC;
self->old_time = new_time;
posx = 0.0f;
posy = 0.0f;
width = 0.0f;
height = 0.0f;
stage_width = 0.0f;
stage_height = 0.0f;
clutter_actor_get_transformed_position (self->actor, &posx, &posy);
clutter_actor_get_transformed_size (self->actor, &width, &height);
self->opacity = clutter_actor_get_paint_opacity (self->actor);
stage = clutter_actor_get_stage (self->actor);
clutter_actor_get_size (stage, &stage_width, &stage_height);
if ((posx < 0) || (posy < 0) || ((posx + width) > stage_width) || ((posy + height) > stage_height))
return FALSE;
if (( posx != self->posx_old)
|| ( posy != self->posy_old)
|| ( width != self->width_old)
|| ( height != self->height_old)
|| (time_used > 50.0))
{
self->posx_old = posx;
self->posy_old = posy;
self->width_old = width;
self->height_old = height;
self->bg_posx_i = round(posx)+2;
self->bg_posy_i = round(posy)+2;
self->bg_width_i = round(width)-4;
self->bg_height_i = round(height)-4;
size = (self->bg_width_i) * (self->bg_height_i) * 4;
if (((self->opacity == 0xff) || (self->bg_texture == NULL)) && (size > 400))
{
rowstride = (self->bg_width_i) * 4;
data = g_malloc (size);
cogl_read_pixels (self->bg_posx_i,
self->bg_posy_i,
self->bg_width_i,
self->bg_height_i,
COGL_READ_PIXELS_COLOR_BUFFER,
COGL_PIXEL_FORMAT_RGBA_8888_PRE,
data);
if (data != NULL)
{
if (self->bg_texture != NULL)
{
cogl_handle_unref (self->bg_texture);
self->bg_texture = NULL;
}
self->bg_texture = st_cogl_texture_new_from_data_wrapper (self->bg_width_i,
self->bg_height_i,
COGL_TEXTURE_NO_SLICING,
COGL_PIXEL_FORMAT_RGBA_8888_PRE,
COGL_PIXEL_FORMAT_RGBA_8888_PRE,
rowstride,
data);
g_free (data);
}
}
}
parent_class = CLUTTER_EFFECT_CLASS (st_background_effect_parent_class);
if (parent_class->pre_paint (effect))
{
ClutterOffscreenEffect *offscreen_effect = CLUTTER_OFFSCREEN_EFFECT (effect);
CoglHandle fg_texture;
fg_texture = clutter_offscreen_effect_get_texture (offscreen_effect);
if (fg_texture != COGL_INVALID_HANDLE)
{
self->fg_width_i = cogl_texture_get_width (fg_texture);
self->fg_height_i = cogl_texture_get_height (fg_texture);
if ((self->bg_texture != NULL) && (self->opacity == 0xff))
{
if (self->pixel_step_uniform0 > -1)
{
gfloat pixel_step[3];
pixel_step[0] = 1.0f / (self->bg_width_i);
pixel_step[1] = 1.0f / (self->bg_height_i);
pixel_step[2] = 0.0f;
cogl_pipeline_set_uniform_float (self->pipeline0,
self->pixel_step_uniform0,
3,
1,
pixel_step);
}
if (self->BumpTex_uniform > -1)
{
cogl_pipeline_set_uniform_1i (self->pipeline0,
self->BumpTex_uniform,
1);
}
if (self->bump_step_uniform > -1)
{
gfloat bump_step[2];
bump_step[0] = 1.0f / (self->bumptex_width_i);
bump_step[1] = 1.0f / (self->bumptex_height_i);
cogl_pipeline_set_uniform_float (self->pipeline0,
self->bump_step_uniform,
2,
1,
bump_step);
}
if (self->bg_sub_texture != NULL)
{
cogl_handle_unref (self->bg_sub_texture);
self->bg_sub_texture = NULL;
}
self->bg_sub_texture = st_cogl_texture_new_with_size_wrapper (self->bg_width_i, self->bg_height_i,
COGL_TEXTURE_NO_SLICING,
COGL_PIXEL_FORMAT_RGBA_8888_PRE);
cogl_pipeline_set_layer_texture (self->pipeline0, 0, self->bg_texture);
if (self->pixel_step_uniform1 > -1)
{
gfloat pixel_step[3];
pixel_step[0] = 1.0f / (self->bg_width_i);
pixel_step[1] = 1.0f / (self->bg_height_i);
pixel_step[2] = 1.0f;
cogl_pipeline_set_uniform_float (self->pipeline1,
self->pixel_step_uniform1,
3,
1,
pixel_step);
}
if (self->pixel_step_uniform2 > -1)
{
gfloat pixel_step[3];
pixel_step[0] = 1.0f / (self->fg_width_i);
pixel_step[1] = 1.0f / (self->fg_height_i);
pixel_step[2] = 2.0f;
cogl_pipeline_set_uniform_float (self->pipeline3,
self->pixel_step_uniform2,
3,
1,
pixel_step);
}
}
cogl_pipeline_set_layer_texture (self->pipeline2, 0, fg_texture);
cogl_pipeline_set_layer_texture (self->pipeline3, 0, fg_texture);
cogl_pipeline_set_layer_texture (self->pipeline4, 0, fg_texture);
}
return TRUE;
}
else
{
return FALSE;
}
}
static gboolean
clutter_colorize_effect_pre_paint (ClutterEffect *effect)
{
ClutterColorizeEffect *self = CLUTTER_COLORIZE_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;
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;
}
if (self->shader == COGL_INVALID_HANDLE)
{
self->shader = cogl_create_shader (COGL_SHADER_TYPE_FRAGMENT);
cogl_shader_source (self->shader, colorize_glsl_shader);
self->is_compiled = FALSE;
self->tex_uniform = -1;
self->tint_uniform = -1;
}
if (self->program == COGL_INVALID_HANDLE)
self->program = cogl_create_program ();
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 colorize 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->tint_uniform =
cogl_program_get_uniform_location (self->program, "tint");
}
}
parent_class = CLUTTER_EFFECT_CLASS (clutter_colorize_effect_parent_class);
return parent_class->pre_paint (effect);
}
