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); }